chart2/source/model/template/ColumnLineChartTypeTemplate.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 "ColumnLineChartTypeTemplate.hxx"
  21 #include "ColumnChartType.hxx"
  22 #include "LineChartType.hxx"
  23 #include <CommonConverters.hxx>
  24 #include <BaseCoordinateSystem.hxx>
  25 #include <Diagram.hxx>
  26 #include <DiagramHelper.hxx>
  27 #include <DataSeries.hxx>
  28 #include <DataSeriesHelper.hxx>
  29 #include <servicenames_charttypes.hxx>
  30 #include "ColumnLineDataInterpreter.hxx"
  31 #include <PropertyHelper.hxx>
  32 #include <com/sun/star/beans/PropertyAttribute.hpp>
  33 #include <com/sun/star/drawing/LineStyle.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_COL_LINE_NUMBER_OF_LINES
  51 };
  52
  53 ::chart::tPropertyValueMap& StaticColumnLineChartTypeTemplateDefaults()
  54 {
  55     static ::chart::tPropertyValueMap aStaticDefaults =
  56         []()
  57         {
  58             ::chart::tPropertyValueMap aOutMap;
  59             ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( aOutMap, PROP_COL_LINE_NUMBER_OF_LINES, 1 );
  60             return aOutMap;
  61         }();
  62     return aStaticDefaults;
  63 }
  64
  65 ::cppu::OPropertyArrayHelper& StaticColumnLineChartTypeTemplateInfoHelper()
  66 {
  67     static ::cppu::OPropertyArrayHelper aPropHelper(
  68         []()
  69         {
  70             std::vector< css::beans::Property > aProperties {
  71                 { u"NumberOfLines"_ustr,
  72                   PROP_COL_LINE_NUMBER_OF_LINES,
  73                   cppu::UnoType<sal_Int32>::get(),
  74                   beans::PropertyAttribute::BOUND
  75                   | beans::PropertyAttribute::MAYBEDEFAULT } };
  76
  77             std::sort( aProperties.begin(), aProperties.end(),
  78                          ::chart::PropertyNameLess() );
  79
  80             return comphelper::containerToSequence( aProperties );
  81         }());
  82     return aPropHelper;
  83 }
  84
  85 uno::Reference< beans::XPropertySetInfo >& StaticColumnLineChartTypeTemplateInfo()
  86 {
  87     static uno::Reference< beans::XPropertySetInfo > xPropertySetInfo(
  88         ::cppu::OPropertySetHelper::createPropertySetInfo(StaticColumnLineChartTypeTemplateInfoHelper() ) );
  89     return xPropertySetInfo;
  90 }
  91
  92 } // anonymous namespace
  93
  94 namespace chart
  95 {
  96
  97 ColumnLineChartTypeTemplate::ColumnLineChartTypeTemplate(
  98     Reference<
  99         uno::XComponentContext > const & xContext,
 100     const OUString & rServiceName,
 101     StackMode eStackMode,
 102     sal_Int32 nNumberOfLines ) :
 103         ChartTypeTemplate( xContext, rServiceName ),
 104         m_eStackMode( eStackMode )
 105 {
 106     setFastPropertyValue_NoBroadcast( PROP_COL_LINE_NUMBER_OF_LINES, uno::Any( nNumberOfLines ));
 107 }
 108
 109 ColumnLineChartTypeTemplate::~ColumnLineChartTypeTemplate()
 110 {}
 111
 112 // ____ OPropertySet ____
 113 void ColumnLineChartTypeTemplate::GetDefaultValue( sal_Int32 nHandle, uno::Any& rAny ) const
 114 {
 115     const tPropertyValueMap& rStaticDefaults = StaticColumnLineChartTypeTemplateDefaults();
 116     tPropertyValueMap::const_iterator aFound( rStaticDefaults.find( nHandle ) );
 117     if( aFound == rStaticDefaults.end() )
 118         rAny.clear();
 119     else
 120         rAny = (*aFound).second;
 121 }
 122
 123 ::cppu::IPropertyArrayHelper & SAL_CALL ColumnLineChartTypeTemplate::getInfoHelper()
 124 {
 125     return StaticColumnLineChartTypeTemplateInfoHelper();
 126 }
 127
 128 // ____ XPropertySet ____
 129 uno::Reference< beans::XPropertySetInfo > SAL_CALL ColumnLineChartTypeTemplate::getPropertySetInfo()
 130 {
 131     return StaticColumnLineChartTypeTemplateInfo();
 132 }
 133
 134 void ColumnLineChartTypeTemplate::createChartTypes(
 135     const std::vector< std::vector< rtl::Reference< DataSeries > > > & aSeriesSeq,
 136     const std::vector< rtl::Reference< BaseCoordinateSystem > > & rCoordSys,
 137     const std::vector< rtl::Reference< ChartType > >& aOldChartTypesSeq )
 138 {
 139     if( rCoordSys.empty() )
 140         return;
 141
 142     try
 143     {
 144         const std::vector< rtl::Reference< DataSeries > > aFlatSeriesSeq( FlattenSequence( aSeriesSeq ));
 145         sal_Int32 nNumberOfSeries = aFlatSeriesSeq.size();
 146         sal_Int32 nNumberOfLines = 0;
 147         sal_Int32 nNumberOfColumns = 0;
 148
 149         getFastPropertyValue( PROP_COL_LINE_NUMBER_OF_LINES ) >>= nNumberOfLines;
 150         OSL_ENSURE( nNumberOfLines>=0, "number of lines should be not negative" );
 151         if( nNumberOfLines < 0 )
 152             nNumberOfLines = 0;
 153
 154         if( nNumberOfLines >= nNumberOfSeries )
 155         {
 156             if( nNumberOfSeries > 0 )
 157             {
 158                 nNumberOfLines = nNumberOfSeries - 1;
 159                 nNumberOfColumns = 1;
 160             }
 161             else
 162                 nNumberOfLines = 0;
 163         }
 164         else
 165             nNumberOfColumns = nNumberOfSeries - nNumberOfLines;
 166
 167         // Columns
 168
 169         rtl::Reference< ChartType > xCT = new ColumnChartType();
 170
 171         ChartTypeTemplate::copyPropertiesFromOldToNewCoordinateSystem( aOldChartTypesSeq, xCT );
 172
 173         rCoordSys[ 0 ]->setChartTypes( std::vector{xCT} );
 174
 175         if( nNumberOfColumns > 0 )
 176         {
 177             std::vector< rtl::Reference< DataSeries > > aColumnSeq( nNumberOfColumns );
 178             std::copy( aFlatSeriesSeq.begin(),
 179                          aFlatSeriesSeq.begin() + nNumberOfColumns,
 180                          aColumnSeq.begin());
 181             xCT->setDataSeries( aColumnSeq );
 182         }
 183
 184         // Lines
 185
 186         xCT = new LineChartType();
 187         rCoordSys[ 0 ]->addChartType( xCT );
 188
 189         if( nNumberOfLines > 0 )
 190         {
 191             std::vector< rtl::Reference< DataSeries > > aLineSeq( nNumberOfLines );
 192             std::copy( aFlatSeriesSeq.begin() + nNumberOfColumns,
 193                          aFlatSeriesSeq.end(),
 194                          aLineSeq.begin());
 195             xCT->setDataSeries( aLineSeq );
 196         }
 197     }
 198     catch( const uno::Exception & )
 199     {
 200         DBG_UNHANDLED_EXCEPTION("chart2");
 201     }
 202 }
 203
 204 void ColumnLineChartTypeTemplate::applyStyle2(
 205     const rtl::Reference< DataSeries >& xSeries,
 206     ::sal_Int32 nChartTypeIndex,
 207     ::sal_Int32 nSeriesIndex,
 208     ::sal_Int32 nSeriesCount )
 209 {
 210     ChartTypeTemplate::applyStyle2( xSeries, nChartTypeIndex, nSeriesIndex, nSeriesCount );
 211
 212     if( nChartTypeIndex==0 ) // columns
 213     {
 214         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, u"BorderStyle"_ustr, uno::Any( drawing::LineStyle_NONE ) );
 215     }
 216     else if( nChartTypeIndex==1 ) // lines
 217     {
 218         DataSeriesHelper::switchLinesOnOrOff( xSeries, true );
 219         DataSeriesHelper::switchSymbolsOnOrOff( xSeries, false, nSeriesIndex );
 220         DataSeriesHelper::makeLinesThickOrThin( xSeries, true );
 221     }
 222 }
 223
 224 StackMode ColumnLineChartTypeTemplate::getStackMode( sal_Int32 nChartTypeIndex ) const
 225 {
 226     if( nChartTypeIndex == 0 )
 227         return m_eStackMode;
 228     return StackMode::NONE;
 229 }
 230
 231 // ____ XChartTypeTemplate ____
 232 bool ColumnLineChartTypeTemplate::matchesTemplate2(
 233     const rtl::Reference< ::chart::Diagram >& xDiagram,
 234     bool bAdaptProperties )
 235 {
 236     bool bResult = false;
 237
 238     if( ! xDiagram.is())
 239         return bResult;
 240
 241     try
 242     {
 243         rtl::Reference< ChartType > xColumnChartType;
 244         rtl::Reference< BaseCoordinateSystem > xColumnChartCooSys;
 245         rtl::Reference< ChartType > xLineChartType;
 246         sal_Int32 nNumberOfChartTypes = 0;
 247
 248         for( rtl::Reference< BaseCoordinateSystem > const & coords : xDiagram->getBaseCoordinateSystems() )
 249         {
 250             const std::vector< rtl::Reference< ChartType > > aChartTypeSeq( coords->getChartTypes2());
 251             for( rtl::Reference< ChartType > const & chartType : aChartTypeSeq )
 252             {
 253                 ++nNumberOfChartTypes;
 254                 if( nNumberOfChartTypes > 2 )
 255                     break;
 256                 OUString aCTService = chartType->getChartType();
 257                 if( aCTService == CHART2_SERVICE_NAME_CHARTTYPE_COLUMN )
 258                 {
 259                     xColumnChartType = chartType;
 260                     xColumnChartCooSys = coords;
 261                 }
 262                 else if( aCTService == CHART2_SERVICE_NAME_CHARTTYPE_LINE )
 263                     xLineChartType = chartType;
 264             }
 265             if( nNumberOfChartTypes > 2 )
 266                 break;
 267         }
 268
 269         if( nNumberOfChartTypes == 2 &&
 270             xColumnChartType.is() &&
 271             xLineChartType.is())
 272         {
 273             OSL_ASSERT( xColumnChartCooSys.is());
 274
 275             // check stackmode of bars
 276             bResult = (xColumnChartCooSys->getDimension() == getDimension());
 277             if( bResult )
 278             {
 279                 bool bFound=false;
 280                 bool bAmbiguous=false;
 281                 bResult = ( DiagramHelper::getStackModeFromChartType(
 282                                 xColumnChartType, bFound, bAmbiguous,
 283                                 xColumnChartCooSys )
 284                             == getStackMode( 0 ) );
 285
 286                 if( bResult && bAdaptProperties )
 287                 {
 288                     if( xLineChartType.is() )
 289                     {
 290                         sal_Int32 nNumberOfLines = xLineChartType->getDataSeries().getLength();
 291                         setFastPropertyValue_NoBroadcast( PROP_COL_LINE_NUMBER_OF_LINES, uno::Any( nNumberOfLines ));
 292                     }
 293                 }
 294             }
 295         }
 296     }
 297     catch( const uno::Exception & )
 298     {
 299         DBG_UNHANDLED_EXCEPTION("chart2");
 300     }
 301
 302     return bResult;
 303 }
 304
 305 rtl::Reference< ChartType > ColumnLineChartTypeTemplate::getChartTypeForIndex( sal_Int32 nChartTypeIndex )
 306 {
 307     if( nChartTypeIndex == 0 )
 308         return new ColumnChartType();
 309     else
 310         return new LineChartType();
 311 }
 312
 313 rtl::Reference< ChartType > ColumnLineChartTypeTemplate::getChartTypeForNewSeries2(
 314         const std::vector< rtl::Reference< ChartType > >& aFormerlyUsedChartTypes )
 315 {
 316     rtl::Reference< ChartType > xResult;
 317
 318     try
 319     {
 320         xResult = new LineChartType();
 321         ChartTypeTemplate::copyPropertiesFromOldToNewCoordinateSystem( aFormerlyUsedChartTypes, xResult );
 322     }
 323     catch( const uno::Exception & )
 324     {
 325         DBG_UNHANDLED_EXCEPTION("chart2");
 326     }
 327
 328     return xResult;
 329 }
 330
 331 rtl::Reference< DataInterpreter > ColumnLineChartTypeTemplate::getDataInterpreter2()
 332 {
 333     if( ! m_xDataInterpreter.is())
 334     {
 335         sal_Int32 nNumberOfLines = 1;
 336         getFastPropertyValue( PROP_COL_LINE_NUMBER_OF_LINES ) >>= nNumberOfLines;
 337         m_xDataInterpreter = new ColumnLineDataInterpreter( nNumberOfLines );
 338     }
 339     else
 340     {
 341         //todo...
 342         OSL_FAIL( "number of lines may not be valid anymore in the datainterpreter" );
 343
 344     }
 345
 346     return m_xDataInterpreter;
 347 }
 348
 349 IMPLEMENT_FORWARD_XINTERFACE2( ColumnLineChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 350 IMPLEMENT_FORWARD_XTYPEPROVIDER2( ColumnLineChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 351
 352 } //  namespace chart
 353
 354 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */