chart2/source/controller/itemsetwrapper/ErrorBarItemConverter.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ErrorBarItemConverter.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33 #include "ErrorBarItemConverter.hxx"
  34 #include "SchWhichPairs.hxx"
  35 #include "macros.hxx"
  36 #include "ItemPropertyMap.hxx"
  37 #include "ErrorBar.hxx"
  38 #include "PropertyHelper.hxx"
  39 #include "ChartModelHelper.hxx"
  40 #include "ChartTypeHelper.hxx"
  41 #include "StatisticsHelper.hxx"
  42
  43 #include "GraphicPropertyItemConverter.hxx"
  44
  45 #include <svtools/stritem.hxx>
  46 #include <svx/chrtitem.hxx>
  47 #include <svtools/intitem.hxx>
  48 #include <rtl/math.hxx>
  49
  50 #include <com/sun/star/chart2/DataPointLabel.hpp>
  51 #include <com/sun/star/chart2/XInternalDataProvider.hpp>
  52 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  53 #include <com/sun/star/lang/XServiceName.hpp>
  54
  55 #include <functional>
  56 #include <algorithm>
  57 #include <vector>
  58
  59 using namespace ::com::sun::star;
  60
  61 namespace
  62 {
  63
  64 void lcl_getErrorValues( const uno::Reference< beans::XPropertySet > & xErrorBarProp,
  65                     double & rOutPosError, double & rOutNegError )
  66 {
  67     if( ! xErrorBarProp.is())
  68         return;
  69
  70     try
  71     {
  72         xErrorBarProp->getPropertyValue( C2U( "PositiveError" )) >>= rOutPosError;
  73         xErrorBarProp->getPropertyValue( C2U( "NegativeError" )) >>= rOutNegError;
  74     }
  75     catch( uno::Exception & ex )
  76     {
  77         ASSERT_EXCEPTION( ex );
  78     }
  79 }
  80
  81 void lcl_getErrorIndicatorValues(
  82     const uno::Reference< beans::XPropertySet > & xErrorBarProp,
  83     bool & rOutShowPosError, bool & rOutShowNegError )
  84 {
  85     if( ! xErrorBarProp.is())
  86         return;
  87
  88     try
  89     {
  90         xErrorBarProp->getPropertyValue( C2U( "ShowPositiveError" )) >>= rOutShowPosError;
  91         xErrorBarProp->getPropertyValue( C2U( "ShowNegativeError" )) >>= rOutShowNegError;
  92     }
  93     catch( uno::Exception & ex )
  94     {
  95         ASSERT_EXCEPTION( ex );
  96     }
  97 }
  98
  99 } // anonymous namespace
 100
 101 namespace chart
 102 {
 103 namespace wrapper
 104 {
 105
 106 ErrorBarItemConverter::ErrorBarItemConverter(
 107     const uno::Reference< frame::XModel > & xModel,
 108     const uno::Reference< beans::XPropertySet > & rPropertySet,
 109     SfxItemPool& rItemPool,
 110     SdrModel& rDrawModel,
 111     const uno::Reference< lang::XMultiServiceFactory > & xNamedPropertyContainerFactory ) :
 112         ItemConverter( rPropertySet, rItemPool ),
 113         m_spGraphicConverter( new GraphicPropertyItemConverter(
 114                                   rPropertySet, rItemPool, rDrawModel,
 115                                   xNamedPropertyContainerFactory,
 116                                   GraphicPropertyItemConverter::LINE_PROPERTIES )),
 117         m_xModel( xModel )
 118 {}
 119
 120 ErrorBarItemConverter::~ErrorBarItemConverter()
 121 {}
 122
 123 void ErrorBarItemConverter::FillItemSet( SfxItemSet & rOutItemSet ) const
 124 {
 125     m_spGraphicConverter->FillItemSet( rOutItemSet );
 126
 127     // own items
 128     ItemConverter::FillItemSet( rOutItemSet );
 129 }
 130
 131 bool ErrorBarItemConverter::ApplyItemSet( const SfxItemSet & rItemSet )
 132 {
 133     bool bResult = m_spGraphicConverter->ApplyItemSet( rItemSet );
 134
 135     // own items
 136     return ItemConverter::ApplyItemSet( rItemSet ) || bResult;
 137 }
 138
 139 const USHORT * ErrorBarItemConverter::GetWhichPairs() const
 140 {
 141     // must span all used items!
 142     return nErrorBarWhichPairs;
 143 }
 144
 145 bool ErrorBarItemConverter::GetItemProperty(
 146     tWhichIdType /* nWhichId */,
 147     tPropertyNameWithMemberId & /* rOutProperty */ ) const
 148 {
 149     return false;
 150 }
 151
 152 bool ErrorBarItemConverter::ApplySpecialItem(
 153     USHORT nWhichId, const SfxItemSet & rItemSet )
 154     throw( uno::Exception )
 155 {
 156     bool bChanged = false;
 157     uno::Any aValue;
 158
 159     switch( nWhichId )
 160     {
 161         // Attention !!! This case must be passed before SCHATTR_STAT_PERCENT,
 162         // SCHATTR_STAT_BIGERROR, SCHATTR_STAT_CONSTPLUS,
 163         // SCHATTR_STAT_CONSTMINUS and SCHATTR_STAT_INDICATE
 164         case SCHATTR_STAT_KIND_ERROR:
 165         {
 166             uno::Reference< beans::XPropertySet > xErrorBarProp( GetPropertySet());
 167
 168             SvxChartKindError eErrorKind =
 169                 static_cast< const SvxChartKindErrorItem & >(
 170                     rItemSet.Get( nWhichId )).GetValue();
 171
 172             if( !xErrorBarProp.is() && eErrorKind == CHERROR_NONE)
 173             {
 174                 //nothing to do
 175             }
 176             else
 177             {
 178                 sal_Int32 nStyle = ::com::sun::star::chart::ErrorBarStyle::NONE;
 179
 180                 switch( eErrorKind )
 181                 {
 182                     case CHERROR_NONE:
 183                         nStyle = ::com::sun::star::chart::ErrorBarStyle::NONE; break;
 184                     case CHERROR_VARIANT:
 185                         nStyle = ::com::sun::star::chart::ErrorBarStyle::VARIANCE; break;
 186                     case CHERROR_SIGMA:
 187                         nStyle = ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION; break;
 188                     case CHERROR_PERCENT:
 189                         nStyle = ::com::sun::star::chart::ErrorBarStyle::RELATIVE; break;
 190                     case CHERROR_BIGERROR:
 191                         nStyle = ::com::sun::star::chart::ErrorBarStyle::ERROR_MARGIN; break;
 192                     case CHERROR_CONST:
 193                         nStyle = ::com::sun::star::chart::ErrorBarStyle::ABSOLUTE; break;
 194                     case CHERROR_STDERROR:
 195                         nStyle = ::com::sun::star::chart::ErrorBarStyle::STANDARD_ERROR; break;
 196                     case CHERROR_RANGE:
 197                         nStyle = ::com::sun::star::chart::ErrorBarStyle::FROM_DATA; break;
 198                 }
 199
 200                 xErrorBarProp->setPropertyValue( C2U( "ErrorBarStyle" ),
 201                                                     uno::makeAny( nStyle ));
 202                 bChanged = true;
 203             }
 204         }
 205         break;
 206
 207         case SCHATTR_STAT_PERCENT:
 208         case SCHATTR_STAT_BIGERROR:
 209         {
 210             OSL_ENSURE( false, "Deprectaed item" );
 211             uno::Reference< beans::XPropertySet > xErrorBarProp( GetPropertySet());
 212
 213             double fValue =
 214                 static_cast< const SvxDoubleItem & >(
 215                     rItemSet.Get( nWhichId )).GetValue();
 216             double fPos, fNeg;
 217             lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
 218
 219             if( ! ( ::rtl::math::approxEqual( fPos, fValue ) &&
 220                     ::rtl::math::approxEqual( fNeg, fValue )))
 221             {
 222                 xErrorBarProp->setPropertyValue( C2U( "PositiveError" ),
 223                                                     uno::makeAny( fValue ));
 224                 xErrorBarProp->setPropertyValue( C2U( "NegativeError" ),
 225                                                     uno::makeAny( fValue ));
 226                 bChanged = true;
 227             }
 228         }
 229         break;
 230
 231         case SCHATTR_STAT_CONSTPLUS:
 232         {
 233             double fValue =
 234                 static_cast< const SvxDoubleItem & >(
 235                     rItemSet.Get( nWhichId )).GetValue();
 236             double fPos, fNeg;
 237             lcl_getErrorValues( GetPropertySet(), fPos, fNeg );
 238
 239             if( ! ::rtl::math::approxEqual( fPos, fValue ))
 240             {
 241                 GetPropertySet()->setPropertyValue( C2U( "PositiveError" ), uno::makeAny( fValue ));
 242                 bChanged = true;
 243             }
 244         }
 245         break;
 246
 247         case SCHATTR_STAT_CONSTMINUS:
 248         {
 249             uno::Reference< beans::XPropertySet > xErrorBarProp( GetPropertySet());
 250
 251             double fValue =
 252                 static_cast< const SvxDoubleItem & >(
 253                     rItemSet.Get( nWhichId )).GetValue();
 254             double fPos, fNeg;
 255             lcl_getErrorValues( xErrorBarProp, fPos, fNeg );
 256
 257             if( ! ::rtl::math::approxEqual( fNeg, fValue ))
 258             {
 259                 xErrorBarProp->setPropertyValue( C2U( "NegativeError" ), uno::makeAny( fValue ));
 260                 bChanged = true;
 261             }
 262         }
 263         break;
 264
 265         case SCHATTR_STAT_INDICATE:
 266         {
 267             uno::Reference< beans::XPropertySet > xErrorBarProp( GetPropertySet());
 268
 269             SvxChartIndicate eIndicate =
 270                 static_cast< const SvxChartIndicateItem & >(
 271                     rItemSet.Get( nWhichId )).GetValue();
 272
 273             bool bNewIndPos = (eIndicate == CHINDICATE_BOTH || eIndicate == CHINDICATE_UP );
 274             bool bNewIndNeg = (eIndicate == CHINDICATE_BOTH || eIndicate == CHINDICATE_DOWN );
 275
 276             bool bShowPos, bShowNeg;
 277             lcl_getErrorIndicatorValues( xErrorBarProp, bShowPos, bShowNeg );
 278
 279             if( ( bShowPos != bNewIndPos ||
 280                   bShowNeg != bNewIndNeg ))
 281             {
 282                 xErrorBarProp->setPropertyValue( C2U( "ShowPositiveError" ), uno::makeAny( bNewIndPos ));
 283                 xErrorBarProp->setPropertyValue( C2U( "ShowNegativeError" ), uno::makeAny( bNewIndNeg ));
 284                 bChanged = true;
 285             }
 286         }
 287         break;
 288
 289         case SCHATTR_STAT_RANGE_POS:
 290         case SCHATTR_STAT_RANGE_NEG:
 291         {
 292             // @todo: also be able to deal with x-error bars
 293             const bool bYError = true;
 294             uno::Reference< chart2::data::XDataSource > xErrorBarSource( GetPropertySet(), uno::UNO_QUERY );
 295             uno::Reference< chart2::XChartDocument > xChartDoc( m_xModel, uno::UNO_QUERY );
 296             uno::Reference< chart2::data::XDataProvider > xDataProvider;
 297
 298             if( xChartDoc.is())
 299                 xDataProvider.set( xChartDoc->getDataProvider());
 300             if( xErrorBarSource.is() && xDataProvider.is())
 301             {
 302                 ::rtl::OUString aNewRange( static_cast< const SfxStringItem & >( rItemSet.Get( nWhichId )).GetValue());
 303                 bool bApplyNewRange = false;
 304
 305                 bool bIsPositiveValue( nWhichId == SCHATTR_STAT_RANGE_POS );
 306                 if( xChartDoc->hasInternalDataProvider())
 307                 {
 308                     if( aNewRange.getLength())
 309                     {
 310                         uno::Reference< chart2::data::XDataSequence > xSeq(
 311                             StatisticsHelper::getErrorDataSequenceFromDataSource(
 312                                 xErrorBarSource, bIsPositiveValue, bYError ));
 313                         if( ! xSeq.is())
 314                         {
 315                             // no data range for error bars yet => create
 316                             uno::Reference< chart2::XInternalDataProvider > xIntDataProvider( xDataProvider, uno::UNO_QUERY );
 317                             OSL_ASSERT( xIntDataProvider.is());
 318                             if( xIntDataProvider.is())
 319                             {
 320                                 xIntDataProvider->appendSequence();
 321                                 aNewRange = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("last"));
 322                                 bApplyNewRange = true;
 323                             }
 324                         }
 325                     }
 326                 }
 327                 else
 328                 {
 329                     uno::Reference< chart2::data::XDataSequence > xSeq(
 330                         StatisticsHelper::getErrorDataSequenceFromDataSource(
 331                             xErrorBarSource, bIsPositiveValue, bYError ));
 332                     bApplyNewRange =
 333                         ! ( xSeq.is() && aNewRange.equals( xSeq->getSourceRangeRepresentation()));
 334                 }
 335
 336                 if( bApplyNewRange )
 337                     StatisticsHelper::setErrorDataSequence(
 338                         xErrorBarSource, xDataProvider, aNewRange, bIsPositiveValue, bYError );
 339             }
 340         }
 341         break;
 342     }
 343
 344     return bChanged;
 345 }
 346
 347 void ErrorBarItemConverter::FillSpecialItem(
 348     USHORT nWhichId, SfxItemSet & rOutItemSet ) const
 349     throw( uno::Exception )
 350 {
 351     switch( nWhichId )
 352     {
 353         case SCHATTR_STAT_KIND_ERROR:
 354         {
 355             SvxChartKindError eErrorKind = CHERROR_NONE;
 356             uno::Reference< beans::XPropertySet > xErrorBarProp( GetPropertySet());
 357
 358             sal_Int32 nStyle = 0;
 359             if( xErrorBarProp->getPropertyValue( C2U( "ErrorBarStyle" )) >>= nStyle )
 360             {
 361                 switch( nStyle )
 362                 {
 363                     case ::com::sun::star::chart::ErrorBarStyle::NONE:
 364                         break;
 365                     case ::com::sun::star::chart::ErrorBarStyle::VARIANCE:
 366                         eErrorKind = CHERROR_VARIANT; break;
 367                     case ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION:
 368                         eErrorKind = CHERROR_SIGMA; break;
 369                     case ::com::sun::star::chart::ErrorBarStyle::ABSOLUTE:
 370                         eErrorKind = CHERROR_CONST; break;
 371                     case ::com::sun::star::chart::ErrorBarStyle::RELATIVE:
 372                         eErrorKind = CHERROR_PERCENT; break;
 373                     case ::com::sun::star::chart::ErrorBarStyle::ERROR_MARGIN:
 374                         eErrorKind = CHERROR_BIGERROR; break;
 375                     case ::com::sun::star::chart::ErrorBarStyle::STANDARD_ERROR:
 376                         eErrorKind = CHERROR_STDERROR; break;
 377                     case ::com::sun::star::chart::ErrorBarStyle::FROM_DATA:
 378                         eErrorKind = CHERROR_RANGE; break;
 379                 }
 380             }
 381             rOutItemSet.Put( SvxChartKindErrorItem( eErrorKind, SCHATTR_STAT_KIND_ERROR ));
 382         }
 383         break;
 384
 385         case SCHATTR_STAT_PERCENT:
 386         {
 387             double fPos, fNeg;
 388             lcl_getErrorValues( GetPropertySet(), fPos, fNeg );
 389             rOutItemSet.Put( SvxDoubleItem( ( fPos + fNeg ) / 2.0, nWhichId ));
 390         }
 391         break;
 392
 393         case SCHATTR_STAT_BIGERROR:
 394         {
 395             double fPos, fNeg;
 396             lcl_getErrorValues( GetPropertySet(), fPos, fNeg );
 397             rOutItemSet.Put( SvxDoubleItem( ( fPos + fNeg ) / 2.0, nWhichId ));
 398         }
 399         break;
 400
 401         case SCHATTR_STAT_CONSTPLUS:
 402         {
 403             double fPos, fNeg;
 404             lcl_getErrorValues( GetPropertySet(), fPos, fNeg );
 405             rOutItemSet.Put( SvxDoubleItem( fPos, nWhichId ));
 406         }
 407         break;
 408
 409         case SCHATTR_STAT_CONSTMINUS:
 410         {
 411             double fPos, fNeg;
 412             lcl_getErrorValues( GetPropertySet(), fPos, fNeg );
 413             rOutItemSet.Put( SvxDoubleItem( fNeg, nWhichId ));
 414         }
 415         break;
 416
 417         case SCHATTR_STAT_INDICATE:
 418         {
 419             SvxChartIndicate eIndicate = CHINDICATE_BOTH;
 420             bool bShowPos, bShowNeg;
 421             lcl_getErrorIndicatorValues( GetPropertySet(), bShowPos, bShowNeg );
 422
 423             if( bShowPos )
 424             {
 425                 if( bShowNeg )
 426                     eIndicate = CHINDICATE_BOTH;
 427                 else
 428                     eIndicate = CHINDICATE_UP;
 429             }
 430             else
 431             {
 432                 if( bShowNeg )
 433                     eIndicate = CHINDICATE_DOWN;
 434                 else
 435                     eIndicate = CHINDICATE_NONE;
 436             }
 437             rOutItemSet.Put( SvxChartIndicateItem( eIndicate, SCHATTR_STAT_INDICATE ));
 438         }
 439         break;
 440
 441         case SCHATTR_STAT_RANGE_POS:
 442         case SCHATTR_STAT_RANGE_NEG:
 443         {
 444             uno::Reference< chart2::data::XDataSource > xErrorBarSource( GetPropertySet(), uno::UNO_QUERY );
 445             if( xErrorBarSource.is())
 446             {
 447                 uno::Reference< chart2::data::XDataSequence > xSeq(
 448                     StatisticsHelper::getErrorDataSequenceFromDataSource(
 449                         xErrorBarSource, (nWhichId == SCHATTR_STAT_RANGE_POS) /*, true */ /* y */ ));
 450                 if( xSeq.is())
 451                     rOutItemSet.Put( SfxStringItem( nWhichId, String( xSeq->getSourceRangeRepresentation())));
 452             }
 453         }
 454         break;
 455    }
 456 }
 457
 458 } //  namespace wrapper
 459 } //  namespace chart