chart2/source/controller/chartapiwrapper/WrappedSplineProperties.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 "WrappedSplineProperties.hxx"
  21 #include "Chart2ModelContact.hxx"
  22 #include <FastPropertyIdRanges.hxx>
  23 #include <ChartType.hxx>
  24 #include <WrappedProperty.hxx>
  25 #include <unonames.hxx>
  26
  27 #include <sal/log.hxx>
  28
  29 #include <com/sun/star/chart2/CurveStyle.hpp>
  30 #include <com/sun/star/beans/PropertyAttribute.hpp>
  31 #include <com/sun/star/beans/XPropertySet.hpp>
  32 #include <utility>
  33
  34 using namespace ::com::sun::star;
  35 using ::com::sun::star::uno::Any;
  36 using ::com::sun::star::beans::Property;
  37
  38 namespace chart::wrapper
  39 {
  40
  41 namespace
  42 {
  43
  44 //PROPERTYTYPE is the type of the outer property
  45
  46 template< typename PROPERTYTYPE >
  47 class WrappedSplineProperty : public WrappedProperty
  48 {
  49 public:
  50     explicit WrappedSplineProperty( const OUString& rOuterName, OUString aInnerName
  51         , const css::uno::Any& rDefaulValue
  52         , std::shared_ptr<Chart2ModelContact> spChart2ModelContact )
  53             : WrappedProperty(rOuterName,OUString())
  54             , m_spChart2ModelContact(std::move(spChart2ModelContact))
  55             , m_aOuterValue(rDefaulValue)
  56             , m_aDefaultValue(rDefaulValue)
  57             , m_aOwnInnerName(std::move(aInnerName))
  58     {
  59     }
  60
  61     bool detectInnerValue( PROPERTYTYPE& rValue, bool& rHasAmbiguousValue ) const
  62     {
  63         rHasAmbiguousValue = false;
  64         rtl::Reference<Diagram> xDiagram = m_spChart2ModelContact->getDiagram();
  65         if (!xDiagram)
  66             return false;
  67         bool bHasDetectableInnerValue = false;
  68         std::vector< rtl::Reference< ChartType > > aChartTypes = xDiagram->getChartTypes();
  69         for( sal_Int32 nN = aChartTypes.size(); nN--; )
  70         {
  71             try
  72             {
  73                 Any aSingleValue = convertInnerToOuterValue( aChartTypes[nN]->getPropertyValue(m_aOwnInnerName) );
  74                 PROPERTYTYPE aCurValue = PROPERTYTYPE();
  75                 aSingleValue >>= aCurValue;
  76                 if( !bHasDetectableInnerValue )
  77                     rValue = aCurValue;
  78                 else
  79                 {
  80                     if( rValue != aCurValue )
  81                     {
  82                         rHasAmbiguousValue = true;
  83                         break;
  84                     }
  85                     else
  86                         rValue = aCurValue;
  87                 }
  88                 bHasDetectableInnerValue = true;
  89             }
  90             catch( uno::Exception & ex )
  91             {
  92                 //spline properties are not supported by all charttypes
  93                 //in that cases this exception is ok
  94                 ex.Context.is();//to have debug information without compilation warnings
  95             }
  96         }
  97         return bHasDetectableInnerValue;
  98     }
  99     void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& /*xInnerPropertySet*/ ) const override
 100     {
 101         PROPERTYTYPE aNewValue;
 102         if( ! (rOuterValue >>= aNewValue) )
 103             throw css::lang::IllegalArgumentException( u"spline property requires different type"_ustr, nullptr, 0 );
 104
 105         m_aOuterValue = rOuterValue;
 106
 107         bool bHasAmbiguousValue = false;
 108         PROPERTYTYPE aOldValue = PROPERTYTYPE();
 109         if( !detectInnerValue( aOldValue, bHasAmbiguousValue ) )
 110             return;
 111
 112         if( !(bHasAmbiguousValue || aNewValue != aOldValue) )
 113             return;
 114
 115         std::vector< rtl::Reference< ChartType > > aChartTypes =
 116             m_spChart2ModelContact->getDiagram()->getChartTypes();
 117         for( sal_Int32 nN = aChartTypes.size(); nN--; )
 118         {
 119             try
 120             {
 121                 aChartTypes[nN]->setPropertyValue(m_aOwnInnerName,convertOuterToInnerValue(uno::Any(aNewValue)));
 122             }
 123             catch( uno::Exception & ex )
 124             {
 125                 //spline properties are not supported by all charttypes
 126                 //in that cases this exception is ok
 127                 ex.Context.is();//to have debug information without compilation warnings
 128             }
 129         }
 130     }
 131
 132     css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& /*xInnerPropertySet*/ ) const override
 133     {
 134         bool bHasAmbiguousValue = false;
 135         PROPERTYTYPE aValue;
 136         if( detectInnerValue( aValue, bHasAmbiguousValue ) )
 137         {
 138             m_aOuterValue <<= aValue;
 139         }
 140         return m_aOuterValue;
 141     }
 142
 143     css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& /*xInnerPropertyState*/ ) const override
 144     {
 145         return m_aDefaultValue;
 146     }
 147
 148 protected:
 149     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
 150     mutable css::uno::Any                   m_aOuterValue;
 151     css::uno::Any                           m_aDefaultValue;
 152     // this inner name is not set as inner name at the base class
 153     const OUString m_aOwnInnerName;
 154 };
 155
 156 class WrappedSplineTypeProperty : public WrappedSplineProperty< sal_Int32 >
 157 {
 158 public:
 159     explicit WrappedSplineTypeProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
 160
 161     virtual css::uno::Any convertInnerToOuterValue( const css::uno::Any& rInnerValue ) const override;
 162     virtual css::uno::Any convertOuterToInnerValue( const css::uno::Any& rOuterValue ) const override;
 163 };
 164
 165 enum
 166 {
 167     //spline properties
 168       PROP_CHART_SPLINE_TYPE = FAST_PROPERTY_ID_START_CHART_SPLINE_PROP
 169     , PROP_CHART_SPLINE_ORDER
 170     , PROP_CHART_SPLINE_RESOLUTION
 171 };
 172
 173 }//anonymous namespace
 174
 175 void WrappedSplineProperties::addProperties( std::vector< Property > & rOutProperties )
 176 {
 177     rOutProperties.emplace_back( CHART_UNONAME_SPLINE_TYPE,
 178                   PROP_CHART_SPLINE_TYPE,
 179                   cppu::UnoType<sal_Int32>::get(),
 180                   beans::PropertyAttribute::BOUND
 181                   | beans::PropertyAttribute::MAYBEDEFAULT
 182                   | beans::PropertyAttribute::MAYBEVOID );
 183     rOutProperties.emplace_back( CHART_UNONAME_SPLINE_ORDER,
 184                   PROP_CHART_SPLINE_ORDER,
 185                   cppu::UnoType<sal_Int32>::get(),
 186                   beans::PropertyAttribute::BOUND
 187                   | beans::PropertyAttribute::MAYBEDEFAULT
 188                   | beans::PropertyAttribute::MAYBEVOID );
 189     rOutProperties.emplace_back( CHART_UNONAME_SPLINE_RESOLUTION,
 190                   PROP_CHART_SPLINE_RESOLUTION,
 191                   cppu::UnoType<sal_Int32>::get(),
 192                   beans::PropertyAttribute::BOUND
 193                   | beans::PropertyAttribute::MAYBEDEFAULT
 194                   | beans::PropertyAttribute::MAYBEVOID );
 195 }
 196
 197 void WrappedSplineProperties::addWrappedProperties( std::vector< std::unique_ptr<WrappedProperty> >& rList
 198                                     , const std::shared_ptr< Chart2ModelContact >& spChart2ModelContact )
 199 {
 200     rList.emplace_back( new WrappedSplineTypeProperty( spChart2ModelContact ) );
 201     rList.emplace_back(
 202         new WrappedSplineProperty<sal_Int32>(
 203             CHART_UNONAME_SPLINE_ORDER, CHART_UNONAME_SPLINE_ORDER,
 204             uno::Any(sal_Int32(3)), spChart2ModelContact));
 205     rList.emplace_back(
 206         new WrappedSplineProperty<sal_Int32>(
 207             CHART_UNONAME_SPLINE_RESOLUTION, CHART_UNONAME_CURVE_RESOLUTION,
 208             uno::Any(sal_Int32(20)), spChart2ModelContact));
 209 }
 210
 211 WrappedSplineTypeProperty::WrappedSplineTypeProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 212     : WrappedSplineProperty<sal_Int32>(CHART_UNONAME_SPLINE_TYPE, CHART_UNONAME_CURVE_STYLE, uno::Any(sal_Int32(0)), spChart2ModelContact )
 213 {
 214 }
 215
 216 Any WrappedSplineTypeProperty::convertInnerToOuterValue( const Any& rInnerValue ) const
 217 {
 218     chart2::CurveStyle aInnerValue = chart2::CurveStyle_LINES;
 219     rInnerValue >>= aInnerValue;
 220
 221     sal_Int32 nOuterValue;
 222     switch (aInnerValue)
 223     {
 224         case chart2::CurveStyle_CUBIC_SPLINES:
 225             nOuterValue = 1;
 226             break;
 227         case chart2::CurveStyle_B_SPLINES:
 228             nOuterValue = 2;
 229             break;
 230         case chart2::CurveStyle_STEP_START:
 231             nOuterValue = 3;
 232             break;
 233         case chart2::CurveStyle_STEP_END:
 234             nOuterValue = 4;
 235             break;
 236         case chart2::CurveStyle_STEP_CENTER_X:
 237             nOuterValue = 5;
 238             break;
 239         case chart2::CurveStyle_STEP_CENTER_Y:
 240             nOuterValue = 6;
 241             break;
 242         default:
 243             nOuterValue = 0;
 244     }
 245
 246     return uno::Any(nOuterValue);
 247 }
 248 Any WrappedSplineTypeProperty::convertOuterToInnerValue( const Any& rOuterValue ) const
 249 {
 250     sal_Int32 nOuterValue=0;
 251     rOuterValue >>= nOuterValue;
 252
 253     chart2::CurveStyle aInnerValue;
 254
 255     switch (nOuterValue)
 256     {
 257         case 1:
 258             aInnerValue = chart2::CurveStyle_CUBIC_SPLINES;
 259             break;
 260         case 2:
 261             aInnerValue = chart2::CurveStyle_B_SPLINES;
 262             break;
 263         case 3:
 264             aInnerValue = chart2::CurveStyle_STEP_START;
 265             break;
 266         case 4:
 267             aInnerValue = chart2::CurveStyle_STEP_END;
 268             break;
 269         case 5:
 270             aInnerValue = chart2::CurveStyle_STEP_CENTER_X;
 271             break;
 272         case 6:
 273             aInnerValue = chart2::CurveStyle_STEP_CENTER_Y;
 274             break;
 275         default:
 276             SAL_WARN_IF(nOuterValue != 0, "chart2", "Unknown line style");
 277             aInnerValue = chart2::CurveStyle_LINES;
 278     }
 279
 280     return uno::Any(aInnerValue);
 281 }
 282
 283 } //namespace chart::wrapper
 284
 285 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */