LCOV - code coverage report
Current view: top level - chart2/source/tools - RegressionCurveHelper.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 333 0.0 %
Date: 2014-04-14 Functions: 0 27 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 "RegressionCurveHelper.hxx"
      21             : #include "MeanValueRegressionCurveCalculator.hxx"
      22             : #include "LinearRegressionCurveCalculator.hxx"
      23             : #include "PolynomialRegressionCurveCalculator.hxx"
      24             : #include "MovingAverageRegressionCurveCalculator.hxx"
      25             : #include "LogarithmicRegressionCurveCalculator.hxx"
      26             : #include "ExponentialRegressionCurveCalculator.hxx"
      27             : #include "PotentialRegressionCurveCalculator.hxx"
      28             : #include "CommonConverters.hxx"
      29             : #include "RegressionCurveModel.hxx"
      30             : #include "ChartTypeHelper.hxx"
      31             : #include "ChartModelHelper.hxx"
      32             : #include "macros.hxx"
      33             : #include "PropertyHelper.hxx"
      34             : #include "ResId.hxx"
      35             : #include "Strings.hrc"
      36             : #include "DiagramHelper.hxx"
      37             : #include <com/sun/star/chart2/XChartDocument.hpp>
      38             : 
      39             : using namespace ::com::sun::star;
      40             : using namespace ::com::sun::star::chart2;
      41             : 
      42             : using ::com::sun::star::uno::Reference;
      43             : using ::com::sun::star::uno::Sequence;
      44             : using ::com::sun::star::uno::XComponentContext;
      45             : using ::com::sun::star::lang::XServiceName;
      46             : using ::com::sun::star::beans::XPropertySet;
      47             : using ::com::sun::star::uno::Exception;
      48             : 
      49             : namespace
      50             : {
      51           0 : OUString lcl_getServiceNameForType( ::chart::RegressionCurveHelper::tRegressionType eType )
      52             : {
      53           0 :     OUString aServiceName;
      54           0 :     switch( eType )
      55             :     {
      56             :         case ::chart::RegressionCurveHelper::REGRESSION_TYPE_LINEAR:
      57           0 :             aServiceName = "com.sun.star.chart2.LinearRegressionCurve";
      58           0 :             break;
      59             :         case ::chart::RegressionCurveHelper::REGRESSION_TYPE_LOG:
      60           0 :             aServiceName = "com.sun.star.chart2.LogarithmicRegressionCurve";
      61           0 :             break;
      62             :         case ::chart::RegressionCurveHelper::REGRESSION_TYPE_EXP:
      63           0 :             aServiceName = "com.sun.star.chart2.ExponentialRegressionCurve";
      64           0 :             break;
      65             :         case ::chart::RegressionCurveHelper::REGRESSION_TYPE_POWER:
      66           0 :             aServiceName = "com.sun.star.chart2.PotentialRegressionCurve";
      67           0 :             break;
      68             :         case ::chart::RegressionCurveHelper::REGRESSION_TYPE_POLYNOMIAL:
      69           0 :             aServiceName = "com.sun.star.chart2.PolynomialRegressionCurve";
      70           0 :             break;
      71             :         case ::chart::RegressionCurveHelper::REGRESSION_TYPE_MOVING_AVERAGE:
      72           0 :             aServiceName = "com.sun.star.chart2.MovingAverageRegressionCurve";
      73           0 :             break;
      74             :         default:
      75             :             OSL_FAIL("unknown regression curve type - use linear instead");
      76           0 :             aServiceName = "com.sun.star.chart2.LinearRegressionCurve";
      77           0 :             break;
      78             :     }
      79           0 :     return aServiceName;
      80             : }
      81             : 
      82             : } // anonymous namespace
      83             : 
      84             : namespace chart
      85             : {
      86             : 
      87           0 : Reference< XRegressionCurve > RegressionCurveHelper::createMeanValueLine(
      88             :     const Reference< XComponentContext > & xContext )
      89             : {
      90             :     return Reference< XRegressionCurve >(
      91           0 :         new MeanValueRegressionCurve( xContext ));
      92             : }
      93             : 
      94           0 : Reference< XRegressionCurve > RegressionCurveHelper::createRegressionCurveByServiceName(
      95             :     const Reference< XComponentContext > & xContext,
      96             :     const OUString& aServiceName )
      97             : {
      98           0 :     Reference< XRegressionCurve > xResult;
      99             : 
     100             :     // todo: use factory methods with service name
     101           0 :     if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
     102             :     {
     103           0 :         xResult.set( new LinearRegressionCurve( xContext ) );
     104             :     }
     105           0 :     else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
     106             :     {
     107           0 :         xResult.set( new LogarithmicRegressionCurve( xContext ) );
     108             :     }
     109           0 :     else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
     110             :     {
     111           0 :         xResult.set( new ExponentialRegressionCurve( xContext ) );
     112             :     }
     113           0 :     else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
     114             :     {
     115           0 :         xResult.set( new PotentialRegressionCurve( xContext ) );
     116             :     }
     117           0 :     else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
     118             :     {
     119           0 :         xResult.set( new PolynomialRegressionCurve( xContext ) );
     120             :     }
     121           0 :     else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
     122             :     {
     123           0 :         xResult.set( new MovingAverageRegressionCurve( xContext ) );
     124             :     }
     125             : 
     126           0 :     return xResult;
     127             : }
     128             : 
     129           0 : Reference< XRegressionCurveCalculator > RegressionCurveHelper::createRegressionCurveCalculatorByServiceName(
     130             :     const OUString& aServiceName )
     131             : {
     132           0 :     Reference< XRegressionCurveCalculator > xResult;
     133             : 
     134             :     // todo: use factory methods with service name
     135           0 :     if( aServiceName == "com.sun.star.chart2.MeanValueRegressionCurve" )
     136             :     {
     137           0 :         xResult.set( new MeanValueRegressionCurveCalculator() );
     138             :     }
     139           0 :     if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
     140             :     {
     141           0 :         xResult.set( new LinearRegressionCurveCalculator() );
     142             :     }
     143           0 :     else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
     144             :     {
     145           0 :         xResult.set( new LogarithmicRegressionCurveCalculator() );
     146             :     }
     147           0 :     else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
     148             :     {
     149           0 :         xResult.set( new ExponentialRegressionCurveCalculator() );
     150             :     }
     151           0 :     else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
     152             :     {
     153           0 :         xResult.set( new PotentialRegressionCurveCalculator() );
     154             :     }
     155           0 :     else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
     156             :     {
     157           0 :         xResult.set( new PolynomialRegressionCurveCalculator() );
     158             :     }
     159           0 :     else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
     160             :     {
     161           0 :         xResult.set( new MovingAverageRegressionCurveCalculator() );
     162             :     }
     163             : 
     164           0 :     return xResult;
     165             : }
     166             : 
     167           0 : void RegressionCurveHelper::initializeCurveCalculator(
     168             :     const Reference< XRegressionCurveCalculator > & xOutCurveCalculator,
     169             :     const Reference< data::XDataSource > & xSource,
     170             :     bool bUseXValuesIfAvailable /* = true */ )
     171             : {
     172           0 :     if( ! (xOutCurveCalculator.is() &&
     173           0 :            xSource.is() ))
     174           0 :         return;
     175             : 
     176           0 :     Sequence< double > aXValues, aYValues;
     177           0 :     bool bXValuesFound = false, bYValuesFound = false;
     178             : 
     179           0 :     Sequence< Reference< data::XLabeledDataSequence > > aDataSeqs( xSource->getDataSequences());
     180           0 :     sal_Int32 i = 0;
     181           0 :     for( i=0;
     182           0 :          ! (bXValuesFound && bYValuesFound) && i<aDataSeqs.getLength();
     183             :          ++i )
     184             :     {
     185             :         try
     186             :         {
     187           0 :             Reference< data::XDataSequence > xSeq( aDataSeqs[i]->getValues());
     188           0 :             Reference< XPropertySet > xProp( xSeq, uno::UNO_QUERY_THROW );
     189           0 :             OUString aRole;
     190           0 :             if( xProp->getPropertyValue( "Role" ) >>= aRole )
     191             :             {
     192           0 :                 if( bUseXValuesIfAvailable && !bXValuesFound && aRole == "values-x" )
     193             :                 {
     194           0 :                     aXValues = DataSequenceToDoubleSequence( xSeq );
     195           0 :                     bXValuesFound = true;
     196             :                 }
     197           0 :                 else if( !bYValuesFound && aRole == "values-y" )
     198             :                 {
     199           0 :                     aYValues = DataSequenceToDoubleSequence( xSeq );
     200           0 :                     bYValuesFound = true;
     201             :                 }
     202           0 :             }
     203             :         }
     204           0 :         catch( const Exception & ex )
     205             :         {
     206             :             ASSERT_EXCEPTION( ex );
     207             :         }
     208             :     }
     209             : 
     210           0 :     if( ! bXValuesFound &&
     211             :         bYValuesFound )
     212             :     {
     213             :         // initialize with 1, 2, ...
     214             :         //first category (index 0) matches with real number 1.0
     215           0 :         aXValues.realloc( aYValues.getLength());
     216           0 :         for( i=0; i<aXValues.getLength(); ++i )
     217           0 :             aXValues[i] = i+1;
     218           0 :         bXValuesFound = true;
     219             :     }
     220             : 
     221           0 :     if( bXValuesFound && bYValuesFound &&
     222           0 :         aXValues.getLength() > 0 &&
     223           0 :         aYValues.getLength() > 0 )
     224           0 :         xOutCurveCalculator->recalculateRegression( aXValues, aYValues );
     225             : }
     226             : 
     227           0 : void RegressionCurveHelper::initializeCurveCalculator(
     228             :     const Reference< XRegressionCurveCalculator > & xOutCurveCalculator,
     229             :     const Reference< XDataSeries > & xSeries,
     230             :     const Reference< frame::XModel > & xModel )
     231             : {
     232             :     sal_Int32 nAxisType = ChartTypeHelper::getAxisType(
     233           0 :         ChartModelHelper::getChartTypeOfSeries( xModel, xSeries ), 0 ); // x-axis
     234             : 
     235             :     initializeCurveCalculator( xOutCurveCalculator,
     236             :                                uno::Reference< data::XDataSource >( xSeries, uno::UNO_QUERY ),
     237           0 :                                (nAxisType == AxisType::REALNUMBER) );
     238           0 : }
     239             : 
     240           0 : bool RegressionCurveHelper::hasMeanValueLine(
     241             :     const uno::Reference< XRegressionCurveContainer > & xRegCnt )
     242             : {
     243           0 :     if( !xRegCnt.is())
     244           0 :         return false;
     245             : 
     246             :     try
     247             :     {
     248             :         uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
     249           0 :             xRegCnt->getRegressionCurves());
     250           0 :         for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     251             :         {
     252           0 :             if( isMeanValueLine( aCurves[i] ))
     253           0 :                 return true;
     254           0 :         }
     255             :     }
     256           0 :     catch( const Exception & ex )
     257             :     {
     258             :         ASSERT_EXCEPTION( ex );
     259             :     }
     260             : 
     261           0 :     return false;
     262             : }
     263             : 
     264           0 : bool RegressionCurveHelper::isMeanValueLine(
     265             :     const uno::Reference< chart2::XRegressionCurve > & xRegCurve )
     266             : {
     267           0 :     uno::Reference< XServiceName > xServName( xRegCurve, uno::UNO_QUERY );
     268           0 :     if( xServName.is() &&
     269           0 :         xServName->getServiceName().equals(
     270           0 :             "com.sun.star.chart2.MeanValueRegressionCurve"))
     271           0 :         return true;
     272           0 :     return false;
     273             : }
     274             : 
     275             : uno::Reference< chart2::XRegressionCurve >
     276           0 :     RegressionCurveHelper::getMeanValueLine(
     277             :         const uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
     278             : {
     279           0 :     if( xRegCnt.is())
     280             :     {
     281             :         try
     282             :         {
     283             :             uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
     284           0 :                 xRegCnt->getRegressionCurves());
     285           0 :             for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     286             :             {
     287           0 :                 if( isMeanValueLine( aCurves[i] ))
     288           0 :                     return aCurves[i];
     289           0 :             }
     290             :         }
     291           0 :         catch( const Exception & ex )
     292             :         {
     293             :             ASSERT_EXCEPTION( ex );
     294             :         }
     295             :     }
     296             : 
     297           0 :     return uno::Reference< chart2::XRegressionCurve >();
     298             : }
     299             : 
     300           0 : void RegressionCurveHelper::addMeanValueLine(
     301             :     uno::Reference< XRegressionCurveContainer > & xRegCnt,
     302             :     const uno::Reference< XComponentContext > & xContext,
     303             :     const uno::Reference< XPropertySet > & xSeriesProp )
     304             : {
     305           0 :     if( !xRegCnt.is() ||
     306           0 :         ::chart::RegressionCurveHelper::hasMeanValueLine( xRegCnt ) )
     307           0 :         return;
     308             : 
     309             :     // todo: use a valid context
     310           0 :     uno::Reference< XRegressionCurve > xCurve( createMeanValueLine( xContext ));
     311           0 :     xRegCnt->addRegressionCurve( xCurve );
     312             : 
     313           0 :     if( xSeriesProp.is())
     314             :     {
     315           0 :         uno::Reference< XPropertySet > xProp( xCurve, uno::UNO_QUERY );
     316           0 :         if( xProp.is())
     317             :         {
     318           0 :             xProp->setPropertyValue( "LineColor",
     319           0 :                                      xSeriesProp->getPropertyValue( "Color"));
     320           0 :         }
     321           0 :     }
     322             : }
     323             : 
     324           0 : void RegressionCurveHelper::removeMeanValueLine(
     325             :     Reference< XRegressionCurveContainer > & xRegCnt )
     326             : {
     327           0 :     if( !xRegCnt.is())
     328           0 :         return;
     329             : 
     330             :     try
     331             :     {
     332             :         Sequence< Reference< XRegressionCurve > > aCurves(
     333           0 :             xRegCnt->getRegressionCurves());
     334           0 :         for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     335             :         {
     336           0 :             if( isMeanValueLine( aCurves[i] ))
     337             :             {
     338           0 :                 xRegCnt->removeRegressionCurve( aCurves[i] );
     339             :                 // attention: the iterator i has become invalid now
     340             : 
     341             :                 // note: assume that there is only one mean-value curve
     342             :                 // to remove multiple mean-value curves remove the break
     343           0 :                 break;
     344             :             }
     345           0 :         }
     346             :     }
     347           0 :     catch( const Exception & ex )
     348             :     {
     349             :         ASSERT_EXCEPTION( ex );
     350             :     }
     351             : }
     352             : 
     353           0 : uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::addRegressionCurve(
     354             :     tRegressionType eType,
     355             :     uno::Reference< XRegressionCurveContainer >& xRegressionCurveContainer,
     356             :     const uno::Reference< XComponentContext >& /* xContext */,
     357             :     const uno::Reference< beans::XPropertySet >& xPropertySource,
     358             :     const uno::Reference< beans::XPropertySet >& xEquationProperties )
     359             : {
     360           0 :     uno::Reference< chart2::XRegressionCurve > xCurve;
     361             : 
     362           0 :     if( !xRegressionCurveContainer.is() )
     363           0 :         return xCurve;
     364             : 
     365           0 :     if( eType == REGRESSION_TYPE_NONE )
     366             :     {
     367             :         OSL_FAIL("don't create a regression curve of type none");
     368           0 :         return xCurve;
     369             :     }
     370             : 
     371           0 :     OUString aServiceName( lcl_getServiceNameForType( eType ));
     372           0 :     if( !aServiceName.isEmpty())
     373             :     {
     374             :         // todo: use a valid context
     375             :         xCurve.set( createRegressionCurveByServiceName(
     376           0 :                          uno::Reference< uno::XComponentContext >(), aServiceName ));
     377             : 
     378           0 :         if( xEquationProperties.is())
     379           0 :             xCurve->setEquationProperties( xEquationProperties );
     380             : 
     381           0 :         uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
     382           0 :         if( xProperties.is())
     383             :         {
     384           0 :             if( xPropertySource.is())
     385           0 :                 comphelper::copyProperties( xPropertySource, xProperties );
     386             :             else
     387             :             {
     388           0 :                 uno::Reference< XPropertySet > xSeriesProp( xRegressionCurveContainer, uno::UNO_QUERY );
     389           0 :                 if( xSeriesProp.is())
     390             :                 {
     391           0 :                     xProperties->setPropertyValue( "LineColor",
     392           0 :                                              xSeriesProp->getPropertyValue( "Color"));
     393           0 :                 }
     394             :             }
     395           0 :         }
     396             :     }
     397           0 :     xRegressionCurveContainer->addRegressionCurve( xCurve );
     398             : 
     399           0 :     return xCurve;
     400             : }
     401             : 
     402             : /** removes all regression curves that are not of type mean value
     403             :     and returns true, if anything was removed
     404             :  */
     405           0 : bool RegressionCurveHelper::removeAllExceptMeanValueLine(
     406             :     uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
     407             : {
     408           0 :     bool bRemovedSomething = false;
     409           0 :     if( xRegCnt.is())
     410             :     {
     411             :         try
     412             :         {
     413             :             uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
     414           0 :                 xRegCnt->getRegressionCurves());
     415           0 :             ::std::vector< uno::Reference< chart2::XRegressionCurve > > aCurvesToDelete;
     416           0 :             for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     417             :             {
     418           0 :                 if( ! isMeanValueLine( aCurves[i] ))
     419             :                 {
     420           0 :                     aCurvesToDelete.push_back( aCurves[ i ] );
     421             :                 }
     422             :             }
     423             : 
     424           0 :             for( ::std::vector< uno::Reference< chart2::XRegressionCurve > >::const_iterator aIt = aCurvesToDelete.begin();
     425           0 :                      aIt != aCurvesToDelete.end(); ++aIt )
     426             :             {
     427           0 :                 xRegCnt->removeRegressionCurve( *aIt );
     428           0 :                 bRemovedSomething = true;
     429           0 :             }
     430             :         }
     431           0 :         catch( const uno::Exception & ex )
     432             :         {
     433             :             ASSERT_EXCEPTION( ex );
     434             :         }
     435             :     }
     436           0 :     return bRemovedSomething;
     437             : }
     438             : 
     439           0 : void RegressionCurveHelper::removeEquations(
     440             :         uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
     441             : {
     442           0 :     if( xRegCnt.is())
     443             :     {
     444             :         try
     445             :         {
     446             :             uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
     447           0 :                 xRegCnt->getRegressionCurves());
     448           0 :             for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     449             :             {
     450           0 :                 if( !isMeanValueLine( aCurves[i] ) )
     451             :                 {
     452           0 :                     uno::Reference< chart2::XRegressionCurve > xRegCurve( aCurves[ i ] );
     453           0 :                     if( xRegCurve.is() )
     454             :                     {
     455           0 :                         uno::Reference< beans::XPropertySet > xEqProp( xRegCurve->getEquationProperties() ) ;
     456           0 :                         if( xEqProp.is())
     457             :                         {
     458           0 :                             xEqProp->setPropertyValue( "ShowEquation", uno::makeAny( false ));
     459           0 :                             xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::makeAny( false ));
     460           0 :                         }
     461           0 :                     }
     462             :                 }
     463           0 :             }
     464             :         }
     465           0 :         catch( const uno::Exception & ex )
     466             :         {
     467             :             ASSERT_EXCEPTION( ex );
     468             :         }
     469             :     }
     470           0 : }
     471             : 
     472           0 : uno::Reference< XRegressionCurve > RegressionCurveHelper::changeRegressionCurveType(
     473             :     tRegressionType eType,
     474             :     uno::Reference< XRegressionCurveContainer > & xRegressionCurveContainer,
     475             :     uno::Reference< XRegressionCurve > & xRegressionCurve,
     476             :     const uno::Reference< XComponentContext > & xContext )
     477             : {
     478           0 :     xRegressionCurveContainer->removeRegressionCurve( xRegressionCurve );
     479             :     return RegressionCurveHelper::addRegressionCurve(
     480             :             eType,
     481             :             xRegressionCurveContainer,
     482             :             xContext,
     483             :             uno::Reference< beans::XPropertySet >( xRegressionCurve, uno::UNO_QUERY ),
     484           0 :             xRegressionCurve->getEquationProperties());
     485             : }
     486             : 
     487           0 : uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getFirstCurveNotMeanValueLine(
     488             :     const Reference< XRegressionCurveContainer > & xRegCnt )
     489             : {
     490           0 :     if( !xRegCnt.is())
     491           0 :         return NULL;
     492             : 
     493             :     try
     494             :     {
     495             :         uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
     496           0 :             xRegCnt->getRegressionCurves());
     497           0 :         for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     498             :         {
     499           0 :             if( ! isMeanValueLine( aCurves[i] ))
     500             :             {
     501           0 :                 return aCurves[ i ];
     502             :             }
     503           0 :         }
     504             :     }
     505           0 :     catch( const Exception & ex )
     506             :     {
     507             :         ASSERT_EXCEPTION( ex );
     508             :     }
     509             : 
     510           0 :     return NULL;
     511             : }
     512             : 
     513           0 : uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getRegressionCurveAtIndex(
     514             :     const Reference< XRegressionCurveContainer >& xCurveContainer,
     515             :     sal_Int32 aIndex )
     516             : {
     517           0 :     if( !xCurveContainer.is())
     518           0 :         return NULL;
     519             : 
     520             :     try
     521             :     {
     522           0 :         uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(xCurveContainer->getRegressionCurves());
     523           0 :         if(0 <= aIndex && aIndex < aCurves.getLength())
     524             :         {
     525           0 :             if(!isMeanValueLine(aCurves[aIndex]))
     526           0 :                 return aCurves[aIndex];
     527           0 :         }
     528             :     }
     529           0 :     catch( const Exception & ex )
     530             :     {
     531             :         ASSERT_EXCEPTION( ex );
     532             :     }
     533             : 
     534           0 :     return NULL;
     535             : }
     536             : 
     537           0 : RegressionCurveHelper::tRegressionType RegressionCurveHelper::getRegressionType(
     538             :     const Reference< XRegressionCurve > & xCurve )
     539             : {
     540           0 :     tRegressionType eResult = REGRESSION_TYPE_UNKNOWN;
     541             : 
     542             :     try
     543             :     {
     544           0 :         Reference< lang::XServiceName > xServName( xCurve, uno::UNO_QUERY );
     545           0 :         if( xServName.is())
     546             :         {
     547           0 :             OUString aServiceName( xServName->getServiceName() );
     548             : 
     549           0 :             if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
     550             :             {
     551           0 :                 eResult = REGRESSION_TYPE_LINEAR;
     552             :             }
     553           0 :             else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
     554             :             {
     555           0 :                 eResult = REGRESSION_TYPE_LOG;
     556             :             }
     557           0 :             else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
     558             :             {
     559           0 :                 eResult = REGRESSION_TYPE_EXP;
     560             :             }
     561           0 :             else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
     562             :             {
     563           0 :                 eResult = REGRESSION_TYPE_POWER;
     564             :             }
     565           0 :             else if( aServiceName == "com.sun.star.chart2.MeanValueRegressionCurve" )
     566             :             {
     567           0 :                 eResult = REGRESSION_TYPE_MEAN_VALUE;
     568             :             }
     569           0 :             else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
     570             :             {
     571           0 :                 eResult = REGRESSION_TYPE_POLYNOMIAL;
     572             :             }
     573           0 :             else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
     574             :             {
     575           0 :                 eResult = REGRESSION_TYPE_MOVING_AVERAGE;
     576           0 :             }
     577           0 :         }
     578             :     }
     579           0 :     catch( const Exception & ex )
     580             :     {
     581             :         ASSERT_EXCEPTION( ex );
     582             :     }
     583             : 
     584           0 :     return eResult;
     585             : }
     586             : 
     587           0 : RegressionCurveHelper::tRegressionType RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine(
     588             :     const Reference< XRegressionCurveContainer > & xRegCnt )
     589             : {
     590           0 :     tRegressionType eResult = REGRESSION_TYPE_NONE;
     591             : 
     592           0 :     if( xRegCnt.is())
     593             :     {
     594             :         Sequence< Reference< XRegressionCurve > > aCurves(
     595           0 :             xRegCnt->getRegressionCurves());
     596           0 :         for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     597             :         {
     598           0 :             tRegressionType eType = getRegressionType( aCurves[i] );
     599           0 :             if( eType != REGRESSION_TYPE_MEAN_VALUE &&
     600             :                 eType != REGRESSION_TYPE_UNKNOWN )
     601             :             {
     602           0 :                 eResult = eType;
     603           0 :                 break;
     604             :             }
     605           0 :         }
     606             :     }
     607             : 
     608           0 :     return eResult;
     609             : }
     610             : 
     611           0 : OUString RegressionCurveHelper::getUINameForRegressionCurve( const Reference< XRegressionCurve >& xRegressionCurve )
     612             : {
     613           0 :     OUString aResult = getRegressionCurveSpecificName(xRegressionCurve);
     614           0 :     if (aResult.isEmpty())
     615             :     {
     616           0 :         aResult = getRegressionCurveGenericName(xRegressionCurve);
     617           0 :         if (!aResult.isEmpty())
     618             :         {
     619           0 :             aResult += " (%SERIESNAME)";
     620             :         }
     621             :     }
     622           0 :     return aResult;
     623             : }
     624             : 
     625           0 : OUString RegressionCurveHelper::getRegressionCurveGenericName(const Reference< XRegressionCurve >& xRegressionCurve)
     626             : {
     627           0 :     OUString aResult;
     628           0 :     if(!xRegressionCurve.is())
     629           0 :         return aResult;
     630             : 
     631           0 :     Reference< lang::XServiceName > xServiceName( xRegressionCurve, uno::UNO_QUERY );
     632           0 :     if(!xServiceName.is())
     633           0 :         return aResult;
     634             : 
     635           0 :     OUString aServiceName(xServiceName->getServiceName());
     636             : 
     637           0 :     if( aServiceName == "com.sun.star.chart2.MeanValueRegressionCurve" )
     638             :     {
     639           0 :         aResult = SCH_RESSTR(STR_REGRESSION_MEAN);
     640             :     }
     641           0 :     else if( aServiceName == "com.sun.star.chart2.LinearRegressionCurve" )
     642             :     {
     643           0 :         aResult = SCH_RESSTR(STR_REGRESSION_LINEAR);
     644             :     }
     645           0 :     else if( aServiceName == "com.sun.star.chart2.LogarithmicRegressionCurve" )
     646             :     {
     647           0 :         aResult = SCH_RESSTR(STR_REGRESSION_LOG);
     648             :     }
     649           0 :     else if( aServiceName == "com.sun.star.chart2.ExponentialRegressionCurve" )
     650             :     {
     651           0 :         aResult = SCH_RESSTR(STR_REGRESSION_EXP);
     652             :     }
     653           0 :     else if( aServiceName == "com.sun.star.chart2.PotentialRegressionCurve" )
     654             :     {
     655           0 :         aResult = SCH_RESSTR(STR_REGRESSION_POWER);
     656             :     }
     657           0 :     else if( aServiceName == "com.sun.star.chart2.PolynomialRegressionCurve" )
     658             :     {
     659           0 :         aResult = SCH_RESSTR(STR_REGRESSION_POLYNOMIAL);
     660             :     }
     661           0 :     else if( aServiceName == "com.sun.star.chart2.MovingAverageRegressionCurve" )
     662             :     {
     663           0 :         aResult = SCH_RESSTR(STR_REGRESSION_MOVING_AVERAGE);
     664             :     }
     665           0 :     return aResult;
     666             : }
     667             : 
     668           0 : OUString RegressionCurveHelper::getRegressionCurveSpecificName(const Reference< XRegressionCurve >& xRegressionCurve)
     669             : {
     670           0 :     OUString aResult;
     671             : 
     672           0 :     if(!xRegressionCurve.is())
     673           0 :         return aResult;
     674             : 
     675           0 :     Reference<XPropertySet> xProperties( xRegressionCurve, uno::UNO_QUERY );
     676           0 :     if(!xProperties.is())
     677           0 :         return aResult;
     678             : 
     679           0 :     xProperties->getPropertyValue("CurveName") >>= aResult;
     680             : 
     681           0 :     return aResult;
     682             : }
     683             : 
     684           0 : OUString RegressionCurveHelper::getRegressionCurveName( const Reference< XRegressionCurve >& xRegressionCurve )
     685             : {
     686           0 :     OUString aResult = getRegressionCurveSpecificName(xRegressionCurve);
     687           0 :     if (aResult.isEmpty())
     688           0 :         return getRegressionCurveGenericName(xRegressionCurve);
     689           0 :     return aResult;
     690             : }
     691             : 
     692             : std::vector< Reference< chart2::XRegressionCurve > >
     693           0 :     RegressionCurveHelper::getAllRegressionCurvesNotMeanValueLine(
     694             :         const Reference< chart2::XDiagram > & xDiagram )
     695             : {
     696           0 :     std::vector< Reference< chart2::XRegressionCurve > > aResult;
     697           0 :     std::vector< Reference< chart2::XDataSeries > > aSeries( DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
     698           0 :     for( std::vector< Reference< chart2::XDataSeries > >::iterator aIt( aSeries.begin());
     699           0 :          aIt != aSeries.end(); ++aIt )
     700             :     {
     701           0 :         Reference< chart2::XRegressionCurveContainer > xContainer( *aIt, uno::UNO_QUERY );
     702           0 :         if(xContainer.is())
     703             :         {
     704           0 :             uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(xContainer->getRegressionCurves());
     705           0 :             for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     706             :             {
     707           0 :                 if( ! isMeanValueLine( aCurves[i] ))
     708           0 :                     aResult.push_back( aCurves[i] );
     709           0 :             }
     710             :         }
     711           0 :     }
     712             : 
     713           0 :     return aResult;
     714             : }
     715             : 
     716           0 : void RegressionCurveHelper::resetEquationPosition(
     717             :     const Reference< chart2::XRegressionCurve > & xCurve )
     718             : {
     719           0 :     if( xCurve.is())
     720             :     {
     721             :         try
     722             :         {
     723           0 :             const OUString aPosPropertyName( "RelativePosition" );
     724           0 :             Reference< beans::XPropertySet > xEqProp( xCurve->getEquationProperties()); // since m233: , uno::UNO_SET_THROW );
     725           0 :             if( xEqProp->getPropertyValue( aPosPropertyName ).hasValue())
     726           0 :                 xEqProp->setPropertyValue( aPosPropertyName, uno::Any());
     727             :         }
     728           0 :         catch( const uno::Exception & ex )
     729             :         {
     730             :             ASSERT_EXCEPTION( ex );
     731             :         }
     732             :     }
     733           0 : }
     734             : 
     735           0 : sal_Int32 RegressionCurveHelper::getRegressionCurveIndex(
     736             :     const Reference< chart2::XRegressionCurveContainer >& xContainer,
     737             :     const Reference< chart2::XRegressionCurve >& xCurve )
     738             : {
     739           0 :     if( xContainer.is())
     740             :     {
     741             :         uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
     742           0 :             xContainer->getRegressionCurves());
     743             : 
     744           0 :         for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
     745             :         {
     746           0 :             if( xCurve == aCurves[i] )
     747           0 :                 return i;
     748           0 :         }
     749             :     }
     750           0 :     return -1;
     751             : }
     752             : 
     753           0 : bool RegressionCurveHelper::hasEquation( const Reference< chart2::XRegressionCurve > & xCurve )
     754             : {
     755           0 :     bool bHasEquation = false;
     756           0 :     if( xCurve.is())
     757             :     {
     758           0 :         uno::Reference< beans::XPropertySet > xEquationProp( xCurve->getEquationProperties());
     759           0 :         if( xEquationProp.is())
     760             :         {
     761           0 :             bool bShowEquation = false;
     762           0 :             bool bShowCoefficient = false;
     763           0 :             xEquationProp->getPropertyValue( "ShowEquation") >>= bShowEquation;
     764           0 :             xEquationProp->getPropertyValue( "ShowCorrelationCoefficient") >>= bShowCoefficient;
     765           0 :             bHasEquation = bShowEquation || bShowCoefficient;
     766           0 :         }
     767             :     }
     768           0 :     return bHasEquation;
     769             : }
     770             : 
     771             : } //namespace chart
     772             : 
     773             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10