chart2/source/model/template/LineChartTypeTemplate.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 "LineChartTypeTemplate.hxx"
  21 #include "LineChartType.hxx"
  22 #include <Diagram.hxx>
  23 #include <DataSeries.hxx>
  24 #include <DataSeriesHelper.hxx>
  25 #include <PropertyHelper.hxx>
  26 #include <ChartType.hxx>
  27 #include <unonames.hxx>
  28
  29 #include <com/sun/star/chart2/CurveStyle.hpp>
  30 #include <com/sun/star/chart2/SymbolStyle.hpp>
  31 #include <com/sun/star/chart2/Symbol.hpp>
  32 #include <com/sun/star/drawing/LineStyle.hpp>
  33 #include <com/sun/star/beans/PropertyAttribute.hpp>
  34 #include <com/sun/star/uno/XComponentContext.hpp>
  35 #include <comphelper/diagnose_ex.hxx>
  36
  37 #include <algorithm>
  38
  39 using namespace ::com::sun::star;
  40
  41 using ::com::sun::star::uno::Reference;
  42 using ::com::sun::star::uno::Sequence;
  43 using ::com::sun::star::beans::Property;
  44
  45 namespace
  46 {
  47
  48 enum
  49 {
  50     PROP_LINECHARTTYPE_TEMPLATE_CURVE_STYLE,
  51     PROP_LINECHARTTYPE_TEMPLATE_CURVE_RESOLUTION,
  52     PROP_LINECHARTTYPE_TEMPLATE_SPLINE_ORDER
  53
  54 };
  55
  56 ::chart::tPropertyValueMap& StaticLineChartTypeTemplateDefaults()
  57 {
  58     static ::chart::tPropertyValueMap aStaticDefaults =
  59         []()
  60         {
  61             ::chart::tPropertyValueMap aOutMap;
  62             ::chart::PropertyHelper::setPropertyValueDefault( aOutMap, PROP_LINECHARTTYPE_TEMPLATE_CURVE_STYLE, chart2::CurveStyle_LINES );
  63             ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( aOutMap, PROP_LINECHARTTYPE_TEMPLATE_CURVE_RESOLUTION, 20 );
  64
  65             // todo: check whether order 3 means polygons of order 3 or 2. (see
  66             // http://www.people.nnov.ru/fractal/Splines/Basis.htm )
  67             ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( aOutMap, PROP_LINECHARTTYPE_TEMPLATE_SPLINE_ORDER, 3 );
  68             return aOutMap;
  69         }();
  70     return aStaticDefaults;
  71 }
  72
  73 ::cppu::OPropertyArrayHelper& StaticLineChartTypeTemplateInfoHelper()
  74 {
  75     static ::cppu::OPropertyArrayHelper aPropHelper(
  76         []()
  77         {
  78             std::vector< css::beans::Property > aProperties {
  79                 { CHART_UNONAME_CURVE_STYLE,
  80                   PROP_LINECHARTTYPE_TEMPLATE_CURVE_STYLE,
  81                   cppu::UnoType<chart2::CurveStyle>::get(),
  82                   beans::PropertyAttribute::BOUND
  83                   | beans::PropertyAttribute::MAYBEDEFAULT },
  84                 { CHART_UNONAME_CURVE_RESOLUTION,
  85                   PROP_LINECHARTTYPE_TEMPLATE_CURVE_RESOLUTION,
  86                   cppu::UnoType<sal_Int32>::get(),
  87                   beans::PropertyAttribute::BOUND
  88                   | beans::PropertyAttribute::MAYBEDEFAULT },
  89                 { CHART_UNONAME_SPLINE_ORDER,
  90                   PROP_LINECHARTTYPE_TEMPLATE_SPLINE_ORDER,
  91                   cppu::UnoType<sal_Int32>::get(),
  92                   beans::PropertyAttribute::BOUND
  93                   | beans::PropertyAttribute::MAYBEDEFAULT } };
  94             std::sort( aProperties.begin(), aProperties.end(),
  95                          ::chart::PropertyNameLess() );
  96
  97             return comphelper::containerToSequence( aProperties );
  98         }());
  99     return aPropHelper;
 100 }
 101
 102 uno::Reference< beans::XPropertySetInfo >& StaticLineChartTypeTemplateInfo()
 103 {
 104     static uno::Reference< beans::XPropertySetInfo > xPropertySetInfo(
 105         ::cppu::OPropertySetHelper::createPropertySetInfo(StaticLineChartTypeTemplateInfoHelper() ) );
 106     return xPropertySetInfo;
 107 }
 108
 109 } // anonymous namespace
 110
 111 namespace chart
 112 {
 113
 114 LineChartTypeTemplate::LineChartTypeTemplate(
 115     uno::Reference<
 116         uno::XComponentContext > const & xContext,
 117     const OUString & rServiceName,
 118     StackMode eStackMode,
 119     bool bSymbols,
 120     bool bHasLines /* = true */,
 121     sal_Int32 nDim /* = 2 */ ) :
 122         ChartTypeTemplate( xContext, rServiceName ),
 123         m_eStackMode( eStackMode ),
 124         m_bHasSymbols( bSymbols ),
 125         m_bHasLines( bHasLines ),
 126         m_nDim( nDim )
 127 {
 128     if( nDim == 3 )
 129         m_bHasSymbols = false;
 130 }
 131
 132 LineChartTypeTemplate::~LineChartTypeTemplate()
 133 {}
 134
 135 // ____ OPropertySet ____
 136 void LineChartTypeTemplate::GetDefaultValue( sal_Int32 nHandle, uno::Any& rAny ) const
 137 {
 138     const tPropertyValueMap& rStaticDefaults = StaticLineChartTypeTemplateDefaults();
 139     tPropertyValueMap::const_iterator aFound( rStaticDefaults.find( nHandle ) );
 140     if( aFound == rStaticDefaults.end() )
 141         rAny.clear();
 142     else
 143         rAny = (*aFound).second;
 144 }
 145
 146 ::cppu::IPropertyArrayHelper & SAL_CALL LineChartTypeTemplate::getInfoHelper()
 147 {
 148     return StaticLineChartTypeTemplateInfoHelper();
 149 }
 150
 151 // ____ XPropertySet ____
 152 uno::Reference< beans::XPropertySetInfo > SAL_CALL LineChartTypeTemplate::getPropertySetInfo()
 153 {
 154     return StaticLineChartTypeTemplateInfo();
 155 }
 156
 157 sal_Int32 LineChartTypeTemplate::getDimension() const
 158 {
 159     return m_nDim;
 160 }
 161
 162 StackMode LineChartTypeTemplate::getStackMode( sal_Int32 /* nChartTypeIndex */ ) const
 163 {
 164     return m_eStackMode;
 165 }
 166
 167 // ____ ChartTypeTemplate ____
 168 bool LineChartTypeTemplate::matchesTemplate2(
 169     const rtl::Reference< ::chart::Diagram >& xDiagram,
 170     bool bAdaptProperties )
 171 {
 172     bool bResult = ChartTypeTemplate::matchesTemplate2( xDiagram, bAdaptProperties );
 173
 174     // check symbol-style and line-style
 175     // for a template with symbols (or with lines) it is ok, if there is at least one series
 176     // with symbols (or with lines)
 177     if( bResult )
 178     {
 179         bool bSymbolFound = false;
 180         bool bLineFound = false;
 181
 182         std::vector< rtl::Reference< DataSeries > > aSeriesVec =
 183             xDiagram->getDataSeries();
 184
 185         for (auto const& series : aSeriesVec)
 186         {
 187             try
 188             {
 189                 chart2::Symbol aSymbProp;
 190                 drawing::LineStyle eLineStyle;
 191
 192                 bool bCurrentHasSymbol = (series->getPropertyValue( u"Symbol"_ustr) >>= aSymbProp) &&
 193                     (aSymbProp.Style != chart2::SymbolStyle_NONE);
 194
 195                 if( bCurrentHasSymbol )
 196                     bSymbolFound = true;
 197
 198                 if( bCurrentHasSymbol && (!m_bHasSymbols) )
 199                 {
 200                     bResult = false;
 201                     break;
 202                 }
 203
 204                 bool bCurrentHasLine = (series->getPropertyValue( u"LineStyle"_ustr) >>= eLineStyle) &&
 205                     ( eLineStyle != drawing::LineStyle_NONE );
 206
 207                 if( bCurrentHasLine )
 208                     bLineFound = true;
 209
 210                 if( bCurrentHasLine && (!m_bHasLines) )
 211                 {
 212                     bResult = false;
 213                     break;
 214                 }
 215             }
 216             catch( const uno::Exception & )
 217             {
 218                 DBG_UNHANDLED_EXCEPTION("chart2");
 219             }
 220         }
 221
 222         if(bResult)
 223         {
 224             if( !bLineFound && m_bHasLines && bSymbolFound )
 225                 bResult = false;
 226             else if( !bSymbolFound && m_bHasSymbols && bLineFound )
 227                 bResult = false;
 228             else if( !bLineFound && !bSymbolFound )
 229                 return m_bHasLines && m_bHasSymbols;
 230         }
 231     }
 232
 233     // adapt curve style, spline order and resolution
 234     if( bResult && bAdaptProperties )
 235     {
 236         try
 237         {
 238             rtl::Reference< ChartType > xChartType = xDiagram->getChartTypeByIndex( 0 );
 239             setFastPropertyValue_NoBroadcast( PROP_LINECHARTTYPE_TEMPLATE_CURVE_STYLE, xChartType->getPropertyValue(CHART_UNONAME_CURVE_STYLE) );
 240             setFastPropertyValue_NoBroadcast( PROP_LINECHARTTYPE_TEMPLATE_CURVE_RESOLUTION, xChartType->getPropertyValue(CHART_UNONAME_CURVE_RESOLUTION) );
 241             setFastPropertyValue_NoBroadcast( PROP_LINECHARTTYPE_TEMPLATE_SPLINE_ORDER, xChartType->getPropertyValue(CHART_UNONAME_SPLINE_ORDER) );
 242         }
 243         catch( const uno::Exception & )
 244         {
 245             DBG_UNHANDLED_EXCEPTION("chart2");
 246         }
 247     }
 248
 249     return bResult;
 250 }
 251
 252 rtl::Reference< ChartType > LineChartTypeTemplate::getChartTypeForIndex( sal_Int32 /*nChartTypeIndex*/ )
 253 {
 254     rtl::Reference< ChartType > xResult;
 255
 256     try
 257     {
 258         xResult = new LineChartType();
 259
 260         xResult->setPropertyValue(
 261             CHART_UNONAME_CURVE_STYLE, getFastPropertyValue( PROP_LINECHARTTYPE_TEMPLATE_CURVE_STYLE ));
 262         xResult->setPropertyValue(
 263             CHART_UNONAME_CURVE_RESOLUTION, getFastPropertyValue( PROP_LINECHARTTYPE_TEMPLATE_CURVE_RESOLUTION ));
 264         xResult->setPropertyValue(
 265             CHART_UNONAME_SPLINE_ORDER, getFastPropertyValue( PROP_LINECHARTTYPE_TEMPLATE_SPLINE_ORDER ));
 266     }
 267     catch( const uno::Exception & )
 268     {
 269         DBG_UNHANDLED_EXCEPTION("chart2");
 270     }
 271
 272     return xResult;
 273 }
 274
 275 rtl::Reference< ChartType > LineChartTypeTemplate::getChartTypeForNewSeries2(
 276         const std::vector< rtl::Reference< ChartType > >& aFormerlyUsedChartTypes )
 277 {
 278     rtl::Reference< ChartType > xResult;
 279
 280     try
 281     {
 282         xResult = new LineChartType();
 283
 284         ChartTypeTemplate::copyPropertiesFromOldToNewCoordinateSystem( aFormerlyUsedChartTypes, xResult );
 285
 286         xResult->setPropertyValue(
 287             CHART_UNONAME_CURVE_STYLE, getFastPropertyValue( PROP_LINECHARTTYPE_TEMPLATE_CURVE_STYLE ));
 288         xResult->setPropertyValue(
 289             CHART_UNONAME_CURVE_RESOLUTION, getFastPropertyValue( PROP_LINECHARTTYPE_TEMPLATE_CURVE_RESOLUTION ));
 290         xResult->setPropertyValue(
 291             CHART_UNONAME_SPLINE_ORDER, getFastPropertyValue( PROP_LINECHARTTYPE_TEMPLATE_SPLINE_ORDER ));
 292     }
 293     catch( const uno::Exception & )
 294     {
 295         DBG_UNHANDLED_EXCEPTION("chart2");
 296     }
 297
 298     return xResult;
 299 }
 300
 301 void LineChartTypeTemplate::applyStyle2(
 302     const rtl::Reference< DataSeries >& xSeries,
 303     ::sal_Int32 nChartTypeIndex,
 304     ::sal_Int32 nSeriesIndex,
 305     ::sal_Int32 nSeriesCount )
 306 {
 307     ChartTypeTemplate::applyStyle2( xSeries, nChartTypeIndex, nSeriesIndex, nSeriesCount );
 308
 309     try
 310     {
 311         DataSeriesHelper::switchSymbolsOnOrOff( xSeries, m_bHasSymbols, nSeriesIndex );
 312         DataSeriesHelper::switchLinesOnOrOff( xSeries, m_bHasLines );
 313         DataSeriesHelper::makeLinesThickOrThin( xSeries, m_nDim==2 );
 314     }
 315     catch( const uno::Exception & )
 316     {
 317         DBG_UNHANDLED_EXCEPTION("chart2");
 318     }
 319 }
 320
 321 IMPLEMENT_FORWARD_XINTERFACE2( LineChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 322 IMPLEMENT_FORWARD_XTYPEPROVIDER2( LineChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 323
 324 } //  namespace chart
 325
 326 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */