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