LCOV - code coverage report
Current view: top level - chart2/source/controller/itemsetwrapper - StatisticsItemConverter.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 351 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 21 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 "StatisticsItemConverter.hxx"
      21             : #include "SchWhichPairs.hxx"
      22             : #include "macros.hxx"
      23             : #include "RegressionCurveHelper.hxx"
      24             : #include "ItemPropertyMap.hxx"
      25             : #include "ErrorBar.hxx"
      26             : #include "PropertyHelper.hxx"
      27             : #include "ChartModelHelper.hxx"
      28             : #include "ChartTypeHelper.hxx"
      29             : #include "StatisticsHelper.hxx"
      30             : 
      31             : #include "GraphicPropertyItemConverter.hxx"
      32             : #include <unonames.hxx>
      33             : 
      34             : #include <svl/stritem.hxx>
      35             : #include <svx/chrtitem.hxx>
      36             : #include <svl/intitem.hxx>
      37             : #include <rtl/math.hxx>
      38             : 
      39             : #include <com/sun/star/chart2/DataPointLabel.hpp>
      40             : #include <com/sun/star/chart2/XInternalDataProvider.hpp>
      41             : #include <com/sun/star/chart/ErrorBarStyle.hpp>
      42             : #include <com/sun/star/lang/XServiceName.hpp>
      43             : 
      44             : #include <functional>
      45             : #include <algorithm>
      46             : #include <vector>
      47             : 
      48             : using namespace ::com::sun::star;
      49             : 
      50             : namespace
      51             : {
      52             : 
      53           0 : uno::Reference< beans::XPropertySet > lcl_GetErrorBar(
      54             :     const uno::Reference< beans::XPropertySet > & xProp, bool bYError )
      55             : {
      56           0 :     uno::Reference< beans::XPropertySet > xResult;
      57             : 
      58           0 :     if( xProp.is())
      59             :         try
      60             :         {
      61           0 :         ( xProp->getPropertyValue( bYError ? OUString(CHART_UNONAME_ERRORBAR_Y) : OUString(CHART_UNONAME_ERRORBAR_X) ) >>= xResult );
      62             :         }
      63           0 :         catch( const uno::Exception & ex )
      64             :         {
      65             :             ASSERT_EXCEPTION( ex );
      66             :         }
      67             : 
      68           0 :     return xResult;
      69             : }
      70             : 
      71           0 : uno::Reference< beans::XPropertySet > lcl_GetDefaultErrorBar()
      72             : {
      73             :     // todo: use a valid context
      74             :     return uno::Reference< beans::XPropertySet >(
      75           0 :         ::chart::createErrorBar( uno::Reference< uno::XComponentContext >()));
      76             : }
      77             : 
      78           0 : void lcl_getErrorValues( const uno::Reference< beans::XPropertySet > & xErrorBarProp,
      79             :                     double & rOutPosError, double & rOutNegError )
      80             : {
      81           0 :     if( ! xErrorBarProp.is())
      82           0 :         return;
      83             : 
      84             :     try
      85             :     {
      86           0 :         xErrorBarProp->getPropertyValue( "PositiveError" ) >>= rOutPosError;
      87           0 :         xErrorBarProp->getPropertyValue( "NegativeError" ) >>= rOutNegError;
      88             :     }
      89           0 :     catch( const uno::Exception & ex )
      90             :     {
      91             :         ASSERT_EXCEPTION( ex );
      92             :     }
      93             : }
      94             : 
      95           0 : void lcl_getErrorIndicatorValues(
      96             :     const uno::Reference< beans::XPropertySet > & xErrorBarProp,
      97             :     bool & rOutShowPosError, bool & rOutShowNegError )
      98             : {
      99           0 :     if( ! xErrorBarProp.is())
     100           0 :         return;
     101             : 
     102             :     try
     103             :     {
     104           0 :         xErrorBarProp->getPropertyValue( "ShowPositiveError" ) >>= rOutShowPosError;
     105           0 :         xErrorBarProp->getPropertyValue( "ShowNegativeError" ) >>= rOutShowNegError;
     106             :     }
     107           0 :     catch( const uno::Exception & ex )
     108             :     {
     109             :         ASSERT_EXCEPTION( ex );
     110             :     }
     111             : }
     112             : 
     113           0 : uno::Reference< beans::XPropertySet > lcl_getEquationProperties(
     114             :     const uno::Reference< beans::XPropertySet > & xSeriesPropSet, const SfxItemSet * pItemSet )
     115             : {
     116           0 :     bool bEquationExists = true;
     117             : 
     118             :     // ensure that a trendline is on
     119           0 :     if( pItemSet )
     120             :     {
     121           0 :         SvxChartRegress eRegress = CHREGRESS_NONE;
     122           0 :         const SfxPoolItem *pPoolItem = NULL;
     123           0 :         if( pItemSet->GetItemState( SCHATTR_REGRESSION_TYPE, true, &pPoolItem ) == SfxItemState::SET )
     124             :         {
     125           0 :             eRegress = static_cast< const SvxChartRegressItem * >( pPoolItem )->GetValue();
     126           0 :             bEquationExists = ( eRegress != CHREGRESS_NONE );
     127             :         }
     128             :     }
     129             : 
     130           0 :     if( bEquationExists )
     131             :     {
     132           0 :         uno::Reference< chart2::XRegressionCurveContainer > xRegCnt( xSeriesPropSet, uno::UNO_QUERY );
     133             :         uno::Reference< chart2::XRegressionCurve > xCurve(
     134           0 :             ::chart::RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt ));
     135           0 :         if( xCurve.is())
     136             :         {
     137           0 :             return xCurve->getEquationProperties();
     138           0 :         }
     139             :     }
     140             : 
     141           0 :     return uno::Reference< beans::XPropertySet >();
     142             : }
     143             : 
     144           0 : uno::Reference< beans::XPropertySet > lcl_getCurveProperties(
     145             :     const uno::Reference< beans::XPropertySet > & xSeriesPropSet, const SfxItemSet * pItemSet )
     146             : {
     147           0 :     bool bExists = true;
     148             : 
     149             :     // ensure that a trendline is on
     150           0 :     if( pItemSet )
     151             :     {
     152           0 :         SvxChartRegress eRegress = CHREGRESS_NONE;
     153           0 :         const SfxPoolItem *pPoolItem = NULL;
     154           0 :         if( pItemSet->GetItemState( SCHATTR_REGRESSION_TYPE, true, &pPoolItem ) == SfxItemState::SET )
     155             :         {
     156           0 :             eRegress = static_cast< const SvxChartRegressItem * >( pPoolItem )->GetValue();
     157           0 :             bExists = ( eRegress != CHREGRESS_NONE );
     158             :         }
     159             :     }
     160             : 
     161           0 :     if( bExists )
     162             :     {
     163           0 :         uno::Reference< chart2::XRegressionCurveContainer > xRegCnt( xSeriesPropSet, uno::UNO_QUERY );
     164             :         uno::Reference< chart2::XRegressionCurve > xCurve(
     165           0 :             ::chart::RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt ));
     166           0 :         if( xCurve.is())
     167             :         {
     168           0 :             uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
     169           0 :             return xProperties;
     170           0 :         }
     171             :     }
     172             : 
     173           0 :     return uno::Reference< beans::XPropertySet >();
     174             : }
     175             : 
     176             : template <class T, class D>
     177           0 : bool lclConvertToPropertySet(const SfxItemSet& rItemSet, sal_uInt16 nWhichId, uno::Reference<beans::XPropertySet> xProperties, const OUString& aPropertyID)
     178             : {
     179             :     OSL_ASSERT(xProperties.is());
     180           0 :     if( xProperties.is() )
     181             :     {
     182           0 :         T aValue = static_cast<T>(static_cast<const D&>(rItemSet.Get( nWhichId )).GetValue());
     183           0 :         T aOldValue = aValue;
     184           0 :         bool aSuccess = xProperties->getPropertyValue( aPropertyID ) >>= aOldValue;
     185           0 :         if (!aSuccess || aOldValue != aValue)
     186             :         {
     187           0 :             xProperties->setPropertyValue( aPropertyID , uno::makeAny( aValue ));
     188           0 :             return true;
     189           0 :         }
     190             :     }
     191           0 :     return false;
     192             : }
     193             : 
     194             : template <class T, class D>
     195           0 : void lclConvertToItemSet(SfxItemSet& rItemSet, sal_uInt16 nWhichId, uno::Reference<beans::XPropertySet> xProperties, const OUString& aPropertyID)
     196             : {
     197             :     OSL_ASSERT(xProperties.is());
     198           0 :     if( xProperties.is() )
     199             :     {
     200           0 :         T aValue = static_cast<T>(static_cast<const D&>(rItemSet.Get( nWhichId )).GetValue());
     201           0 :         if(xProperties->getPropertyValue( aPropertyID ) >>= aValue)
     202             :         {
     203           0 :             rItemSet.Put(D( nWhichId, aValue ));
     204           0 :         }
     205             :     }
     206           0 : }
     207             : 
     208           0 : void lclConvertToItemSetDouble(SfxItemSet& rItemSet, sal_uInt16 nWhichId, uno::Reference<beans::XPropertySet> xProperties, const OUString& aPropertyID)
     209             : {
     210             :     OSL_ASSERT(xProperties.is());
     211           0 :     if( xProperties.is() )
     212             :     {
     213           0 :         double aValue = static_cast<double>(static_cast<const SvxDoubleItem&>(rItemSet.Get( nWhichId )).GetValue());
     214           0 :         if(xProperties->getPropertyValue( aPropertyID ) >>= aValue)
     215             :         {
     216           0 :             rItemSet.Put(SvxDoubleItem( aValue, nWhichId ));
     217             :         }
     218             :     }
     219           0 : }
     220             : 
     221             : } // anonymous namespace
     222             : 
     223             : namespace chart
     224             : {
     225             : namespace wrapper
     226             : {
     227             : 
     228           0 : StatisticsItemConverter::StatisticsItemConverter(
     229             :     const uno::Reference< frame::XModel > & xModel,
     230             :     const uno::Reference< beans::XPropertySet > & rPropertySet,
     231             :     SfxItemPool& rItemPool ) :
     232             :         ItemConverter( rPropertySet, rItemPool ),
     233           0 :         m_xModel( xModel )
     234             : {
     235           0 : }
     236             : 
     237           0 : StatisticsItemConverter::~StatisticsItemConverter()
     238             : {
     239           0 : }
     240             : 
     241           0 : const sal_uInt16 * StatisticsItemConverter::GetWhichPairs() const
     242             : {
     243             :     // must span all used items!
     244           0 :     return nStatWhichPairs;
     245             : }
     246             : 
     247           0 : bool StatisticsItemConverter::GetItemProperty(
     248             :     tWhichIdType /* nWhichId */,
     249             :     tPropertyNameWithMemberId & /* rOutProperty */ ) const
     250             : {
     251           0 :     return false;
     252             : }
     253             : 
     254           0 : bool StatisticsItemConverter::ApplySpecialItem(
     255             :     sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
     256             :     throw( uno::Exception )
     257             : {
     258           0 :     bool bChanged = false;
     259             : 
     260           0 :     switch( nWhichId )
     261             :     {
     262             :         case SCHATTR_STAT_AVERAGE:
     263             :         {
     264             :             uno::Reference< chart2::XRegressionCurveContainer > xRegCnt(
     265           0 :                 GetPropertySet(), uno::UNO_QUERY );
     266           0 :             bool bOldHasMeanValueLine = RegressionCurveHelper::hasMeanValueLine( xRegCnt );
     267             : 
     268             :             bool bNewHasMeanValueLine =
     269           0 :                 static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
     270             : 
     271           0 :             if( bOldHasMeanValueLine != bNewHasMeanValueLine )
     272             :             {
     273           0 :                 if( ! bNewHasMeanValueLine )
     274           0 :                     RegressionCurveHelper::removeMeanValueLine( xRegCnt );
     275             :                 else
     276             :                     RegressionCurveHelper::addMeanValueLine(
     277           0 :                         xRegCnt, uno::Reference< uno::XComponentContext >(), GetPropertySet() );
     278           0 :                 bChanged = true;
     279           0 :             }
     280             :         }
     281           0 :         break;
     282             : 
     283             :         // Attention !!! This case must be passed before SCHATTR_STAT_PERCENT,
     284             :         // SCHATTR_STAT_BIGERROR, SCHATTR_STAT_CONSTPLUS,
     285             :         // SCHATTR_STAT_CONSTMINUS and SCHATTR_STAT_INDICATE
     286             :         case SCHATTR_STAT_KIND_ERROR:
     287             :         {
     288             :             bool bYError =
     289           0 :                 static_cast<const SfxBoolItem&>(rItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     290             : 
     291             :             uno::Reference< beans::XPropertySet > xErrorBarProp(
     292           0 :                 lcl_GetErrorBar( GetPropertySet(), bYError ));
     293             : 
     294             :             SvxChartKindError eErrorKind =
     295             :                 static_cast< const SvxChartKindErrorItem & >(
     296           0 :                     rItemSet.Get( nWhichId )).GetValue();
     297             : 
     298           0 :             if( !xErrorBarProp.is() && eErrorKind == CHERROR_NONE)
     299             :             {
     300             :                 //nothing to do
     301             :             }
     302             :             else
     303             :             {
     304           0 :                 sal_Int32 nStyle = ::com::sun::star::chart::ErrorBarStyle::NONE;
     305             : 
     306           0 :                 switch( eErrorKind )
     307             :                 {
     308             :                     case CHERROR_NONE:
     309           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::NONE; break;
     310             :                     case CHERROR_VARIANT:
     311           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::VARIANCE; break;
     312             :                     case CHERROR_SIGMA:
     313           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION; break;
     314             :                     case CHERROR_PERCENT:
     315           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::RELATIVE; break;
     316             :                     case CHERROR_BIGERROR:
     317           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::ERROR_MARGIN; break;
     318             :                     case CHERROR_CONST:
     319           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::ABSOLUTE; break;
     320             :                     case CHERROR_STDERROR:
     321           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::STANDARD_ERROR; break;
     322             :                     case CHERROR_RANGE:
     323           0 :                         nStyle = ::com::sun::star::chart::ErrorBarStyle::FROM_DATA; break;
     324             :                 }
     325             : 
     326           0 :                 if( !xErrorBarProp.is() )
     327             :                 {
     328           0 :                     xErrorBarProp = lcl_GetDefaultErrorBar();
     329           0 :                     GetPropertySet()->setPropertyValue( bYError ? OUString(CHART_UNONAME_ERRORBAR_Y) : OUString(CHART_UNONAME_ERRORBAR_X),
     330           0 :                                                         uno::makeAny( xErrorBarProp ));
     331             :                 }
     332             : 
     333           0 :                 xErrorBarProp->setPropertyValue( "ErrorBarStyle" , uno::makeAny( nStyle ));
     334           0 :                 bChanged = true;
     335           0 :             }
     336             :         }
     337           0 :         break;
     338             : 
     339             :         case SCHATTR_STAT_PERCENT:
     340             :         case SCHATTR_STAT_BIGERROR:
     341             :         {
     342             :             OSL_FAIL( "Deprecated item" );
     343             :             bool bYError =
     344           0 :                 static_cast<const SfxBoolItem&>(rItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     345             : 
     346             :             uno::Reference< beans::XPropertySet > xErrorBarProp(
     347           0 :                 lcl_GetErrorBar( GetPropertySet(), bYError));
     348           0 :             bool bOldHasErrorBar = xErrorBarProp.is();
     349             : 
     350             :             double fValue =
     351             :                 static_cast< const SvxDoubleItem & >(
     352           0 :                     rItemSet.Get( nWhichId )).GetValue();
     353           0 :             double fPos(0.0), fNeg(0.0);
     354           0 :             lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     355             : 
     356           0 :             if( bOldHasErrorBar &&
     357           0 :                 ! ( ::rtl::math::approxEqual( fPos, fValue ) &&
     358           0 :                     ::rtl::math::approxEqual( fNeg, fValue )))
     359             :             {
     360           0 :                 xErrorBarProp->setPropertyValue( "PositiveError" , uno::makeAny( fValue ));
     361           0 :                 xErrorBarProp->setPropertyValue( "NegativeError" , uno::makeAny( fValue ));
     362           0 :                 bChanged = true;
     363           0 :             }
     364             :         }
     365           0 :         break;
     366             : 
     367             :         case SCHATTR_STAT_CONSTPLUS:
     368             :         {
     369             :             bool bYError =
     370           0 :                 static_cast<const SfxBoolItem&>(rItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     371             : 
     372             :             uno::Reference< beans::XPropertySet > xErrorBarProp(
     373           0 :                 lcl_GetErrorBar( GetPropertySet(),bYError));
     374           0 :             bool bOldHasErrorBar = xErrorBarProp.is();
     375             : 
     376             :             double fValue =
     377             :                 static_cast< const SvxDoubleItem & >(
     378           0 :                     rItemSet.Get( nWhichId )).GetValue();
     379           0 :             double fPos(0.0), fNeg(0.0);
     380           0 :             lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     381             : 
     382           0 :             if( bOldHasErrorBar &&
     383           0 :                 ! ::rtl::math::approxEqual( fPos, fValue ))
     384             :             {
     385           0 :                 xErrorBarProp->setPropertyValue( "PositiveError" , uno::makeAny( fValue ));
     386           0 :                 bChanged = true;
     387           0 :             }
     388             :         }
     389           0 :         break;
     390             : 
     391             :         case SCHATTR_STAT_CONSTMINUS:
     392             :         {
     393             :             bool bYError =
     394           0 :                 static_cast<const SfxBoolItem&>(rItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     395             :             uno::Reference< beans::XPropertySet > xErrorBarProp(
     396           0 :                 lcl_GetErrorBar( GetPropertySet(),bYError));
     397           0 :             bool bOldHasErrorBar = xErrorBarProp.is();
     398             : 
     399             :             double fValue =
     400             :                 static_cast< const SvxDoubleItem & >(
     401           0 :                     rItemSet.Get( nWhichId )).GetValue();
     402           0 :             double fPos(0.0), fNeg(0.0);
     403           0 :             lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     404             : 
     405           0 :             if( bOldHasErrorBar &&
     406           0 :                 ! ::rtl::math::approxEqual( fNeg, fValue ))
     407             :             {
     408           0 :                 xErrorBarProp->setPropertyValue( "NegativeError" , uno::makeAny( fValue ));
     409           0 :                 bChanged = true;
     410           0 :             }
     411             :         }
     412           0 :         break;
     413             : 
     414             :         case SCHATTR_REGRESSION_TYPE:
     415             :         {
     416             :             SvxChartRegress eRegress =
     417             :                 static_cast< const SvxChartRegressItem& >(
     418           0 :                     rItemSet.Get( nWhichId )).GetValue();
     419             : 
     420           0 :             uno::Reference< chart2::XRegressionCurve > xCurve( GetPropertySet(), uno::UNO_QUERY );
     421           0 :             uno::Reference< chart2::XRegressionCurveContainer > xContainer( GetPropertySet(), uno::UNO_QUERY );
     422             : 
     423           0 :             if( eRegress == CHREGRESS_NONE )
     424             :             {
     425           0 :                 if ( xContainer.is() )
     426             :                 {
     427           0 :                     xContainer->removeRegressionCurve( xCurve );
     428           0 :                     bChanged = true;
     429             :                 }
     430             :             }
     431             :             else
     432             :             {
     433           0 :                 if ( xCurve.is() )
     434             :                 {
     435             :                     SvxChartRegress eOldRegress(
     436           0 :                                 RegressionCurveHelper::getRegressionType(xCurve));
     437             : 
     438           0 :                     if( eOldRegress != eRegress )
     439             :                     {
     440           0 :                         xCurve = RegressionCurveHelper::changeRegressionCurveType(
     441             :                                                 eRegress,
     442             :                                                 xContainer,
     443             :                                                 xCurve,
     444           0 :                                                 uno::Reference< uno::XComponentContext >());
     445           0 :                         uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
     446           0 :                         resetPropertySet( xProperties );
     447           0 :                         bChanged = true;
     448             :                     }
     449             :                 }
     450           0 :             }
     451             :         }
     452           0 :         break;
     453             : 
     454             :         case SCHATTR_REGRESSION_DEGREE:
     455             :         {
     456           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     457           0 :             bChanged = lclConvertToPropertySet<sal_Int32, SfxInt32Item>(rItemSet, nWhichId, xProperties, "PolynomialDegree");
     458             :         }
     459           0 :         break;
     460             : 
     461             :         case SCHATTR_REGRESSION_PERIOD:
     462             :         {
     463           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     464           0 :             bChanged = lclConvertToPropertySet<sal_Int32, SfxInt32Item>(rItemSet, nWhichId, xProperties, "MovingAveragePeriod");
     465             :         }
     466           0 :         break;
     467             : 
     468             :         case SCHATTR_REGRESSION_EXTRAPOLATE_FORWARD:
     469             :         {
     470           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     471           0 :             bChanged = lclConvertToPropertySet<double, SvxDoubleItem>(rItemSet, nWhichId, xProperties, "ExtrapolateForward");
     472             :         }
     473           0 :         break;
     474             : 
     475             :         case SCHATTR_REGRESSION_EXTRAPOLATE_BACKWARD:
     476             :         {
     477           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     478           0 :             bChanged = lclConvertToPropertySet<double, SvxDoubleItem>(rItemSet, nWhichId, xProperties, "ExtrapolateBackward");
     479             :         }
     480           0 :         break;
     481             : 
     482             :         case SCHATTR_REGRESSION_SET_INTERCEPT:
     483             :         {
     484           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     485           0 :             bChanged = lclConvertToPropertySet<sal_Bool, SfxBoolItem>(rItemSet, nWhichId, xProperties, "ForceIntercept");
     486             :         }
     487           0 :         break;
     488             : 
     489             :         case SCHATTR_REGRESSION_INTERCEPT_VALUE:
     490             :         {
     491           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     492           0 :             bChanged = lclConvertToPropertySet<double, SvxDoubleItem>(rItemSet, nWhichId, xProperties, "InterceptValue");
     493             :         }
     494           0 :         break;
     495             : 
     496             :         case SCHATTR_REGRESSION_CURVE_NAME:
     497             :         {
     498           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), &rItemSet ));
     499           0 :             bChanged = lclConvertToPropertySet<OUString, SfxStringItem>(rItemSet, nWhichId, xProperties, "CurveName");
     500             :         }
     501           0 :         break;
     502             : 
     503             :         case SCHATTR_REGRESSION_SHOW_EQUATION:
     504             :         {
     505           0 :             uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), &rItemSet ));
     506           0 :             bChanged = lclConvertToPropertySet<sal_Bool, SfxBoolItem>(rItemSet, nWhichId, xEqProp, "ShowEquation");
     507             :         }
     508           0 :         break;
     509             : 
     510             :         case SCHATTR_REGRESSION_SHOW_COEFF:
     511             :         {
     512           0 :             uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), &rItemSet ));
     513           0 :             bChanged = lclConvertToPropertySet<sal_Bool, SfxBoolItem>(rItemSet, nWhichId, xEqProp, "ShowCorrelationCoefficient");
     514             :         }
     515           0 :         break;
     516             : 
     517             :         case SCHATTR_STAT_INDICATE:
     518             :         {
     519             :             bool bYError =
     520           0 :                 static_cast<const SfxBoolItem&>(rItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     521             :             uno::Reference< beans::XPropertySet > xErrorBarProp(
     522           0 :                 lcl_GetErrorBar( GetPropertySet(),bYError));
     523           0 :             bool bOldHasErrorBar = xErrorBarProp.is();
     524             : 
     525             :             SvxChartIndicate eIndicate =
     526             :                 static_cast< const SvxChartIndicateItem & >(
     527           0 :                     rItemSet.Get( nWhichId )).GetValue();
     528             : 
     529           0 :             bool bNewIndPos = (eIndicate == CHINDICATE_BOTH || eIndicate == CHINDICATE_UP );
     530           0 :             bool bNewIndNeg = (eIndicate == CHINDICATE_BOTH || eIndicate == CHINDICATE_DOWN );
     531             : 
     532           0 :             bool bShowPos(false), bShowNeg(false);
     533           0 :             lcl_getErrorIndicatorValues( xErrorBarProp, bShowPos, bShowNeg );
     534             : 
     535           0 :             if( bOldHasErrorBar &&
     536           0 :                 ( bShowPos != bNewIndPos ||
     537           0 :                   bShowNeg != bNewIndNeg ))
     538             :             {
     539           0 :                 xErrorBarProp->setPropertyValue( "ShowPositiveError" , uno::makeAny( bNewIndPos ));
     540           0 :                 xErrorBarProp->setPropertyValue( "ShowNegativeError" , uno::makeAny( bNewIndNeg ));
     541           0 :                 bChanged = true;
     542           0 :             }
     543             :         }
     544           0 :         break;
     545             : 
     546             :         case SCHATTR_STAT_RANGE_POS:
     547             :         case SCHATTR_STAT_RANGE_NEG:
     548             :         {
     549             :             const bool bYError =
     550           0 :                 static_cast<const SfxBoolItem&>(rItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     551             :             uno::Reference< chart2::data::XDataSource > xErrorBarSource( lcl_GetErrorBar( GetPropertySet(), bYError),
     552           0 :                                                                          uno::UNO_QUERY );
     553           0 :             uno::Reference< chart2::XChartDocument > xChartDoc( m_xModel, uno::UNO_QUERY );
     554           0 :             uno::Reference< chart2::data::XDataProvider > xDataProvider;
     555             : 
     556           0 :             if( xChartDoc.is())
     557           0 :                 xDataProvider.set( xChartDoc->getDataProvider());
     558           0 :             if( xErrorBarSource.is() && xDataProvider.is())
     559             :             {
     560           0 :                 OUString aNewRange( static_cast< const SfxStringItem & >( rItemSet.Get( nWhichId )).GetValue());
     561           0 :                 bool bApplyNewRange = false;
     562             : 
     563           0 :                 bool bIsPositiveValue( nWhichId == SCHATTR_STAT_RANGE_POS );
     564           0 :                 if( xChartDoc->hasInternalDataProvider())
     565             :                 {
     566           0 :                     if( !aNewRange.isEmpty())
     567             :                     {
     568             :                         uno::Reference< chart2::data::XDataSequence > xSeq(
     569             :                             StatisticsHelper::getErrorDataSequenceFromDataSource(
     570           0 :                                 xErrorBarSource, bIsPositiveValue, bYError ));
     571           0 :                         if( ! xSeq.is())
     572             :                         {
     573             :                             // no data range for error bars yet => create
     574           0 :                             uno::Reference< chart2::XInternalDataProvider > xIntDataProvider( xDataProvider, uno::UNO_QUERY );
     575             :                             OSL_ASSERT( xIntDataProvider.is());
     576           0 :                             if( xIntDataProvider.is())
     577             :                             {
     578           0 :                                 xIntDataProvider->appendSequence();
     579           0 :                                 aNewRange = "last";
     580           0 :                                 bApplyNewRange = true;
     581           0 :                             }
     582           0 :                         }
     583             :                     }
     584             :                 }
     585             :                 else
     586             :                 {
     587             :                     uno::Reference< chart2::data::XDataSequence > xSeq(
     588             :                         StatisticsHelper::getErrorDataSequenceFromDataSource(
     589           0 :                             xErrorBarSource, bIsPositiveValue, bYError ));
     590             :                     bApplyNewRange =
     591           0 :                         ! ( xSeq.is() && (aNewRange == xSeq->getSourceRangeRepresentation()));
     592             :                 }
     593             : 
     594           0 :                 if( bApplyNewRange )
     595             :                     StatisticsHelper::setErrorDataSequence(
     596           0 :                         xErrorBarSource, xDataProvider, aNewRange, bIsPositiveValue, bYError );
     597           0 :             }
     598             :         }
     599           0 :         break;
     600             :     }
     601             : 
     602           0 :     return bChanged;
     603             : }
     604             : 
     605           0 : void StatisticsItemConverter::FillSpecialItem(
     606             :     sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
     607             :     throw( uno::Exception )
     608             : {
     609           0 :     switch( nWhichId )
     610             :     {
     611             :         case SCHATTR_STAT_AVERAGE:
     612             :             rOutItemSet.Put(
     613             :                 SfxBoolItem( nWhichId,
     614             :                              RegressionCurveHelper::hasMeanValueLine(
     615             :                                  uno::Reference< chart2::XRegressionCurveContainer >(
     616           0 :                                      GetPropertySet(), uno::UNO_QUERY ))));
     617           0 :             break;
     618             : 
     619             :         case SCHATTR_STAT_KIND_ERROR:
     620             :         {
     621             :             bool bYError =
     622           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     623           0 :             SvxChartKindError eErrorKind = CHERROR_NONE;
     624             :             uno::Reference< beans::XPropertySet > xErrorBarProp(
     625           0 :                 lcl_GetErrorBar( GetPropertySet(), bYError));
     626           0 :             if( xErrorBarProp.is() )
     627             :             {
     628           0 :                 sal_Int32 nStyle = 0;
     629           0 :                 if( xErrorBarProp->getPropertyValue( "ErrorBarStyle" ) >>= nStyle )
     630             :                 {
     631           0 :                     switch( nStyle )
     632             :                     {
     633             :                         case ::com::sun::star::chart::ErrorBarStyle::NONE:
     634           0 :                             break;
     635             :                         case ::com::sun::star::chart::ErrorBarStyle::VARIANCE:
     636           0 :                             eErrorKind = CHERROR_VARIANT; break;
     637             :                         case ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION:
     638           0 :                             eErrorKind = CHERROR_SIGMA; break;
     639             :                         case ::com::sun::star::chart::ErrorBarStyle::ABSOLUTE:
     640           0 :                             eErrorKind = CHERROR_CONST; break;
     641             :                         case ::com::sun::star::chart::ErrorBarStyle::RELATIVE:
     642           0 :                             eErrorKind = CHERROR_PERCENT; break;
     643             :                         case ::com::sun::star::chart::ErrorBarStyle::ERROR_MARGIN:
     644           0 :                             eErrorKind = CHERROR_BIGERROR; break;
     645             :                         case ::com::sun::star::chart::ErrorBarStyle::STANDARD_ERROR:
     646           0 :                             eErrorKind = CHERROR_STDERROR; break;
     647             :                         case ::com::sun::star::chart::ErrorBarStyle::FROM_DATA:
     648           0 :                             eErrorKind = CHERROR_RANGE; break;
     649             :                     }
     650             :                 }
     651             :             }
     652           0 :             rOutItemSet.Put( SvxChartKindErrorItem( eErrorKind, SCHATTR_STAT_KIND_ERROR ));
     653             :         }
     654           0 :         break;
     655             : 
     656             :         case SCHATTR_STAT_PERCENT:
     657             :         {
     658             :             bool bYError =
     659           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     660           0 :             uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetErrorBar( GetPropertySet(),bYError));
     661           0 :             if( xErrorBarProp.is())
     662             :             {
     663           0 :                 double fPos(0.0), fNeg(0.0);
     664           0 :                 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     665           0 :                 rOutItemSet.Put( SvxDoubleItem( ( fPos + fNeg ) / 2.0, nWhichId ));
     666           0 :             }
     667             :         }
     668           0 :         break;
     669             : 
     670             :         case SCHATTR_STAT_BIGERROR:
     671             :         {
     672             :             bool bYError =
     673           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     674           0 :             uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetErrorBar( GetPropertySet(),bYError));
     675           0 :             if( xErrorBarProp.is())
     676             :             {
     677           0 :                 double fPos(0.0), fNeg(0.0);
     678           0 :                 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     679           0 :                 rOutItemSet.Put( SvxDoubleItem( ( fPos + fNeg ) / 2.0, nWhichId ));
     680           0 :             }
     681             :         }
     682           0 :         break;
     683             : 
     684             :         case SCHATTR_STAT_CONSTPLUS:
     685             :         {
     686             :             bool bYError =
     687           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     688           0 :             uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetErrorBar( GetPropertySet(),bYError));
     689           0 :             if( xErrorBarProp.is())
     690             :             {
     691           0 :                 double fPos(0.0), fNeg(0.0);
     692           0 :                 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     693           0 :                 rOutItemSet.Put( SvxDoubleItem( fPos, nWhichId ));
     694           0 :             }
     695             :         }
     696           0 :         break;
     697             : 
     698             :         case SCHATTR_STAT_CONSTMINUS:
     699             :         {
     700             :             bool bYError =
     701           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     702           0 :             uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetErrorBar( GetPropertySet(),bYError));
     703           0 :             if( xErrorBarProp.is())
     704             :             {
     705           0 :                 double fPos(0.0), fNeg(0.0);
     706           0 :                 lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
     707           0 :                 rOutItemSet.Put( SvxDoubleItem( fNeg, nWhichId ));
     708           0 :             }
     709             :         }
     710           0 :         break;
     711             : 
     712             :         case SCHATTR_REGRESSION_TYPE:
     713             :         {
     714             :             SvxChartRegress eRegress =
     715             :                     RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine(
     716             :                         uno::Reference< chart2::XRegressionCurveContainer >(
     717           0 :                             GetPropertySet(), uno::UNO_QUERY ) );
     718           0 :             rOutItemSet.Put( SvxChartRegressItem( eRegress, SCHATTR_REGRESSION_TYPE ));
     719             :         }
     720           0 :         break;
     721             : 
     722             :         case SCHATTR_REGRESSION_DEGREE:
     723             :         {
     724             : 
     725           0 :             uno::Reference<beans::XPropertySet> xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     726           0 :             lclConvertToItemSet<sal_Int32, SfxInt32Item>(rOutItemSet, nWhichId, xProperties, "PolynomialDegree");
     727             :         }
     728           0 :         break;
     729             : 
     730             :         case SCHATTR_REGRESSION_PERIOD:
     731             :         {
     732           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     733           0 :             lclConvertToItemSet<sal_Int32, SfxInt32Item>(rOutItemSet, nWhichId, xProperties, "MovingAveragePeriod");
     734             :         }
     735           0 :         break;
     736             : 
     737             :         case SCHATTR_REGRESSION_EXTRAPOLATE_FORWARD:
     738             :         {
     739           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     740           0 :             lclConvertToItemSetDouble(rOutItemSet, nWhichId, xProperties, "ExtrapolateForward");
     741             :         }
     742           0 :         break;
     743             : 
     744             :         case SCHATTR_REGRESSION_EXTRAPOLATE_BACKWARD:
     745             :         {
     746           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     747           0 :             lclConvertToItemSetDouble(rOutItemSet, nWhichId, xProperties, "ExtrapolateBackward");
     748             :         }
     749           0 :         break;
     750             : 
     751             :         case SCHATTR_REGRESSION_SET_INTERCEPT:
     752             :         {
     753           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     754           0 :             lclConvertToItemSet<sal_Bool, SfxBoolItem>(rOutItemSet, nWhichId, xProperties, "ForceIntercept");
     755             :         }
     756           0 :         break;
     757             : 
     758             :         case SCHATTR_REGRESSION_INTERCEPT_VALUE:
     759             :         {
     760           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     761           0 :             lclConvertToItemSetDouble(rOutItemSet, nWhichId, xProperties, "InterceptValue");
     762             :         }
     763           0 :         break;
     764             : 
     765             :         case SCHATTR_REGRESSION_CURVE_NAME:
     766             :         {
     767           0 :             uno::Reference< beans::XPropertySet > xProperties( lcl_getCurveProperties( GetPropertySet(), 0 ));
     768           0 :             lclConvertToItemSet<OUString, SfxStringItem>(rOutItemSet, nWhichId, xProperties, "CurveName");
     769             :         }
     770           0 :         break;
     771             : 
     772             :         case SCHATTR_REGRESSION_SHOW_EQUATION:
     773             :         {
     774           0 :             uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), 0 ));
     775           0 :             lclConvertToItemSet<sal_Bool, SfxBoolItem>(rOutItemSet, nWhichId, xEqProp, "ShowEquation");
     776             :         }
     777           0 :         break;
     778             : 
     779             :         case SCHATTR_REGRESSION_SHOW_COEFF:
     780             :         {
     781           0 :             uno::Reference< beans::XPropertySet > xEqProp( lcl_getEquationProperties( GetPropertySet(), 0 ));
     782           0 :             lclConvertToItemSet<sal_Bool, SfxBoolItem>(rOutItemSet, nWhichId, xEqProp, "ShowCorrelationCoefficient");
     783             :         }
     784           0 :         break;
     785             : 
     786             :         case SCHATTR_STAT_INDICATE:
     787             :         {
     788             :             bool bYError =
     789           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     790           0 :             uno::Reference< beans::XPropertySet > xErrorBarProp( lcl_GetErrorBar( GetPropertySet(),bYError));
     791           0 :             SvxChartIndicate eIndicate = CHINDICATE_BOTH;
     792           0 :             if( xErrorBarProp.is())
     793             :             {
     794           0 :                 bool bShowPos(false), bShowNeg(false);
     795           0 :                 lcl_getErrorIndicatorValues( xErrorBarProp, bShowPos, bShowNeg );
     796             : 
     797           0 :                 if( bShowPos )
     798             :                 {
     799           0 :                     if( bShowNeg )
     800           0 :                         eIndicate = CHINDICATE_BOTH;
     801             :                     else
     802           0 :                         eIndicate = CHINDICATE_UP;
     803             :                 }
     804             :                 else
     805             :                 {
     806           0 :                     if( bShowNeg )
     807           0 :                         eIndicate = CHINDICATE_DOWN;
     808             :                     else
     809           0 :                         eIndicate = CHINDICATE_NONE;
     810             :                 }
     811             :             }
     812           0 :             rOutItemSet.Put( SvxChartIndicateItem( eIndicate, SCHATTR_STAT_INDICATE ));
     813             :         }
     814           0 :         break;
     815             : 
     816             :         case SCHATTR_STAT_RANGE_POS:
     817             :         case SCHATTR_STAT_RANGE_NEG:
     818             :         {
     819             :             bool bYError =
     820           0 :                 static_cast<const SfxBoolItem&>(rOutItemSet.Get(SCHATTR_STAT_ERRORBAR_TYPE)).GetValue();
     821             :             uno::Reference< chart2::data::XDataSource > xErrorBarSource( lcl_GetErrorBar( GetPropertySet(),bYError),
     822           0 :                                                                          uno::UNO_QUERY );
     823           0 :             if( xErrorBarSource.is())
     824             :             {
     825             :                 uno::Reference< chart2::data::XDataSequence > xSeq(
     826             :                     StatisticsHelper::getErrorDataSequenceFromDataSource(
     827           0 :                         xErrorBarSource, (nWhichId == SCHATTR_STAT_RANGE_POS), bYError ));
     828           0 :                 if( xSeq.is())
     829           0 :                     rOutItemSet.Put( SfxStringItem( nWhichId, xSeq->getSourceRangeRepresentation()));
     830           0 :             }
     831             :         }
     832           0 :         break;
     833             :    }
     834           0 : }
     835             : 
     836             : } //  namespace wrapper
     837             : } //  namespace chart
     838             : 
     839             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11