chart2/source/tools/RegressionCurveHelper.cxx

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