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