LCOV - code coverage report
Current view: top level - chart2/source/controller/itemsetwrapper - ErrorBarItemConverter.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 162 0.0 %
Date: 2014-04-14 Functions: 0 11 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10