chart2/source/model/template/ColumnLineChartTypeTemplate.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_chart2.hxx"
  30 #include "ColumnLineChartTypeTemplate.hxx"
  31 #include "macros.hxx"
  32 #include "CommonConverters.hxx"
  33 #include "DiagramHelper.hxx"
  34 #include "DataSeriesHelper.hxx"
  35 #include "servicenames_charttypes.hxx"
  36 #include "ColumnLineDataInterpreter.hxx"
  37 #include "ContainerHelper.hxx"
  38 #include "PropertyHelper.hxx"
  39 #include <com/sun/star/beans/PropertyAttribute.hpp>
  40 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  41 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  42 #include <com/sun/star/drawing/LineStyle.hpp>
  43
  44 #include <algorithm>
  45
  46 using namespace ::com::sun::star::chart2;
  47 using namespace ::com::sun::star;
  48
  49 using ::com::sun::star::uno::Reference;
  50 using ::com::sun::star::uno::Sequence;
  51 using ::rtl::OUString;
  52 using ::com::sun::star::beans::Property;
  53 using ::com::sun::star::uno::Reference;
  54 using ::com::sun::star::uno::Any;
  55 using ::osl::MutexGuard;
  56
  57 namespace
  58 {
  59
  60 static const ::rtl::OUString lcl_aServiceName(
  61     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.ColumnLineChartTypeTemplate" ));
  62
  63 enum
  64 {
  65     PROP_COL_LINE_NUMBER_OF_LINES
  66 };
  67
  68 void lcl_AddPropertiesToVector(
  69     ::std::vector< Property > & rOutProperties )
  70 {
  71     rOutProperties.push_back(
  72         Property( C2U( "NumberOfLines" ),
  73                   PROP_COL_LINE_NUMBER_OF_LINES,
  74                   ::getCppuType( reinterpret_cast< const sal_Int32 * >(0)),
  75                   beans::PropertyAttribute::BOUND
  76                   | beans::PropertyAttribute::MAYBEDEFAULT ));
  77 }
  78
  79 void lcl_AddDefaultsToMap(
  80     ::chart::tPropertyValueMap & rOutMap )
  81 {
  82     ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( rOutMap, PROP_COL_LINE_NUMBER_OF_LINES, 1 );
  83 }
  84
  85 const uno::Sequence< Property > & lcl_GetPropertySequence()
  86 {
  87     static uno::Sequence< Property > aPropSeq;
  88
  89     // /--
  90     MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
  91     if( 0 == aPropSeq.getLength() )
  92     {
  93         // get properties
  94         ::std::vector< ::com::sun::star::beans::Property > aProperties;
  95         lcl_AddPropertiesToVector( aProperties );
  96
  97         // and sort them for access via bsearch
  98         ::std::sort( aProperties.begin(), aProperties.end(),
  99                      ::chart::PropertyNameLess() );
 100
 101         // transfer result to static Sequence
 102         aPropSeq = ::chart::ContainerHelper::ContainerToSequence( aProperties );
 103     }
 104
 105     return aPropSeq;
 106 }
 107
 108 ::cppu::IPropertyArrayHelper & lcl_getInfoHelper()
 109 {
 110     static ::cppu::OPropertyArrayHelper aArrayHelper(
 111         lcl_GetPropertySequence(),
 112         /* bSorted = */ sal_True );
 113
 114     return aArrayHelper;
 115 }
 116
 117 } // anonymous namespace
 118
 119 namespace chart
 120 {
 121
 122 ColumnLineChartTypeTemplate::ColumnLineChartTypeTemplate(
 123     Reference<
 124         uno::XComponentContext > const & xContext,
 125     const ::rtl::OUString & rServiceName,
 126     StackMode eStackMode,
 127     sal_Int32 nNumberOfLines ) :
 128         ChartTypeTemplate( xContext, rServiceName ),
 129         ::property::OPropertySet( m_aMutex ),
 130         m_eStackMode( eStackMode )
 131 {
 132     setFastPropertyValue_NoBroadcast( PROP_COL_LINE_NUMBER_OF_LINES, uno::makeAny( nNumberOfLines ));
 133 }
 134
 135 ColumnLineChartTypeTemplate::~ColumnLineChartTypeTemplate()
 136 {}
 137
 138 // ____ OPropertySet ____
 139 uno::Any ColumnLineChartTypeTemplate::GetDefaultValue( sal_Int32 nHandle ) const
 140     throw(beans::UnknownPropertyException)
 141 {
 142     static tPropertyValueMap aStaticDefaults;
 143
 144     // /--
 145     ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 146     if( 0 == aStaticDefaults.size() )
 147     {
 148         // initialize defaults
 149         lcl_AddDefaultsToMap( aStaticDefaults );
 150     }
 151
 152     tPropertyValueMap::const_iterator aFound(
 153         aStaticDefaults.find( nHandle ));
 154
 155     if( aFound == aStaticDefaults.end())
 156         return uno::Any();
 157
 158     return (*aFound).second;
 159     // \--
 160 }
 161
 162 ::cppu::IPropertyArrayHelper & SAL_CALL ColumnLineChartTypeTemplate::getInfoHelper()
 163 {
 164     return lcl_getInfoHelper();
 165 }
 166
 167
 168 // ____ XPropertySet ____
 169 uno::Reference< beans::XPropertySetInfo > SAL_CALL
 170     ColumnLineChartTypeTemplate::getPropertySetInfo()
 171     throw (uno::RuntimeException)
 172 {
 173     static uno::Reference< beans::XPropertySetInfo > xInfo;
 174
 175     // /--
 176     MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 177     if( !xInfo.is())
 178     {
 179         xInfo = ::cppu::OPropertySetHelper::createPropertySetInfo(
 180             getInfoHelper());
 181     }
 182
 183     return xInfo;
 184     // \--
 185 }
 186
 187 void ColumnLineChartTypeTemplate::createChartTypes(
 188     const Sequence< Sequence< Reference< XDataSeries > > > & aSeriesSeq,
 189     const Sequence< Reference< XCoordinateSystem > > & rCoordSys,
 190     const Sequence< Reference< XChartType > >& aOldChartTypesSeq )
 191 {
 192     if( rCoordSys.getLength() == 0 ||
 193         ! rCoordSys[0].is() )
 194         return;
 195
 196     try
 197     {
 198         Reference< lang::XMultiServiceFactory > xFact(
 199             GetComponentContext()->getServiceManager(), uno::UNO_QUERY_THROW );
 200         Sequence< Reference< XDataSeries > > aFlatSeriesSeq( FlattenSequence( aSeriesSeq ));
 201         sal_Int32 nNumberOfSeries = aFlatSeriesSeq.getLength();
 202         sal_Int32 nNumberOfLines = 0;
 203         sal_Int32 nNumberOfColumns = 0;
 204
 205         getFastPropertyValue( PROP_COL_LINE_NUMBER_OF_LINES ) >>= nNumberOfLines;
 206         OSL_ENSURE( nNumberOfLines>=0, "number of lines should be not negative" );
 207         if( nNumberOfLines < 0 )
 208             nNumberOfLines = 0;
 209
 210         if( nNumberOfLines >= nNumberOfSeries )
 211         {
 212             if( nNumberOfSeries > 0 )
 213             {
 214                 nNumberOfLines = nNumberOfSeries - 1;
 215                 nNumberOfColumns = 1;
 216             }
 217             else
 218                 nNumberOfLines = 0;
 219         }
 220         else
 221             nNumberOfColumns = nNumberOfSeries - nNumberOfLines;
 222
 223         // Columns
 224         // -------
 225         Reference< XChartType > xCT(
 226             xFact->createInstance( CHART2_SERVICE_NAME_CHARTTYPE_COLUMN ), uno::UNO_QUERY_THROW );
 227
 228         ChartTypeTemplate::copyPropertiesFromOldToNewCoordianteSystem( aOldChartTypesSeq, xCT );
 229
 230         Reference< XChartTypeContainer > xCTCnt( rCoordSys[ 0 ], uno::UNO_QUERY_THROW );
 231         xCTCnt->setChartTypes( Sequence< Reference< chart2::XChartType > >( &xCT, 1 ));
 232
 233         if( nNumberOfColumns > 0 )
 234         {
 235             Reference< XDataSeriesContainer > xDSCnt( xCT, uno::UNO_QUERY_THROW );
 236             Sequence< Reference< XDataSeries > > aColumnSeq( nNumberOfColumns );
 237             ::std::copy( aFlatSeriesSeq.getConstArray(),
 238                          aFlatSeriesSeq.getConstArray() + nNumberOfColumns,
 239                          aColumnSeq.getArray());
 240             xDSCnt->setDataSeries( aColumnSeq );
 241         }
 242
 243         // Lines
 244         // -----
 245         xCT.set( xFact->createInstance( CHART2_SERVICE_NAME_CHARTTYPE_LINE ), uno::UNO_QUERY_THROW );
 246         xCTCnt.set( rCoordSys[ 0 ], uno::UNO_QUERY_THROW );
 247         xCTCnt->addChartType( xCT );
 248
 249         if( nNumberOfLines > 0 )
 250         {
 251             Reference< XDataSeriesContainer > xDSCnt( xCT, uno::UNO_QUERY_THROW );
 252             Sequence< Reference< XDataSeries > > aLineSeq( nNumberOfLines );
 253             ::std::copy( aFlatSeriesSeq.getConstArray() + nNumberOfColumns,
 254                          aFlatSeriesSeq.getConstArray() + aFlatSeriesSeq.getLength(),
 255                          aLineSeq.getArray());
 256             xDSCnt->setDataSeries( aLineSeq );
 257         }
 258     }
 259     catch( uno::Exception & ex )
 260     {
 261         ASSERT_EXCEPTION( ex );
 262     }
 263 }
 264
 265 void SAL_CALL ColumnLineChartTypeTemplate::applyStyle(
 266     const Reference< chart2::XDataSeries >& xSeries,
 267     ::sal_Int32 nChartTypeIndex,
 268     ::sal_Int32 nSeriesIndex,
 269     ::sal_Int32 nSeriesCount )
 270     throw (uno::RuntimeException)
 271 {
 272     ChartTypeTemplate::applyStyle( xSeries, nChartTypeIndex, nSeriesIndex, nSeriesCount );
 273
 274     if( nChartTypeIndex==0 ) // columns
 275     {
 276         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, C2U( "BorderStyle" ), uno::makeAny( drawing::LineStyle_NONE ) );
 277     }
 278     else if( nChartTypeIndex==1 ) // lines
 279     {
 280         Reference< beans::XPropertySet > xProp( xSeries, uno::UNO_QUERY );
 281         if( xProp.is() )
 282         {
 283             DataSeriesHelper::switchLinesOnOrOff( xProp, true );
 284             DataSeriesHelper::switchSymbolsOnOrOff( xProp, false, nSeriesIndex );
 285             DataSeriesHelper::makeLinesThickOrThin( xProp, true );
 286         }
 287     }
 288 }
 289
 290 StackMode ColumnLineChartTypeTemplate::getStackMode( sal_Int32 nChartTypeIndex ) const
 291 {
 292     if( nChartTypeIndex == 0 )
 293         return m_eStackMode;
 294     return StackMode_NONE;
 295 }
 296
 297 // ____ XChartTypeTemplate ____
 298 sal_Bool SAL_CALL ColumnLineChartTypeTemplate::matchesTemplate(
 299     const uno::Reference< XDiagram >& xDiagram,
 300     sal_Bool bAdaptProperties )
 301     throw (uno::RuntimeException)
 302 {
 303     sal_Bool bResult = sal_False;
 304
 305     if( ! xDiagram.is())
 306         return bResult;
 307
 308     try
 309     {
 310         Reference< chart2::XChartType > xColumnChartType;
 311         Reference< XCoordinateSystem > xColumnChartCooSys;
 312         Reference< chart2::XChartType > xLineChartType;
 313         sal_Int32 nNumberOfChartTypes = 0;
 314
 315         Reference< XCoordinateSystemContainer > xCooSysCnt(
 316             xDiagram, uno::UNO_QUERY_THROW );
 317         Sequence< Reference< XCoordinateSystem > > aCooSysSeq(
 318             xCooSysCnt->getCoordinateSystems());
 319         for( sal_Int32 i=0; i<aCooSysSeq.getLength(); ++i )
 320         {
 321             Reference< XChartTypeContainer > xCTCnt( aCooSysSeq[i], uno::UNO_QUERY_THROW );
 322             Sequence< Reference< XChartType > > aChartTypeSeq( xCTCnt->getChartTypes());
 323             for( sal_Int32 j=0; j<aChartTypeSeq.getLength(); ++j )
 324             {
 325                 if( aChartTypeSeq[j].is())
 326                 {
 327                     ++nNumberOfChartTypes;
 328                     if( nNumberOfChartTypes > 2 )
 329                         break;
 330                     OUString aCTService = aChartTypeSeq[j]->getChartType();
 331                     if( aCTService.equals( CHART2_SERVICE_NAME_CHARTTYPE_COLUMN ))
 332                     {
 333                         xColumnChartType.set( aChartTypeSeq[j] );
 334                         xColumnChartCooSys.set( aCooSysSeq[i] );
 335                     }
 336                     else if( aCTService.equals( CHART2_SERVICE_NAME_CHARTTYPE_LINE ))
 337                         xLineChartType.set( aChartTypeSeq[j] );
 338                 }
 339             }
 340             if( nNumberOfChartTypes > 2 )
 341                 break;
 342         }
 343
 344         if( nNumberOfChartTypes == 2 &&
 345             xColumnChartType.is() &&
 346             xLineChartType.is())
 347         {
 348             OSL_ASSERT( xColumnChartCooSys.is());
 349
 350             // check stackmode of bars
 351             bResult = (xColumnChartCooSys->getDimension() == getDimension());
 352             if( bResult )
 353             {
 354                 bool bFound=false;
 355                 bool bAmbiguous=false;
 356                 bResult = ( DiagramHelper::getStackModeFromChartType(
 357                                 xColumnChartType, bFound, bAmbiguous,
 358                                 xColumnChartCooSys )
 359                             == getStackMode( 0 ) );
 360
 361                 if( bResult && bAdaptProperties )
 362                 {
 363                     Reference< XDataSeriesContainer > xSeriesContainer( xLineChartType, uno::UNO_QUERY );
 364                     if( xSeriesContainer.is() )
 365                     {
 366                         sal_Int32 nNumberOfLines = xSeriesContainer->getDataSeries().getLength();
 367                         setFastPropertyValue_NoBroadcast( PROP_COL_LINE_NUMBER_OF_LINES, uno::makeAny( nNumberOfLines ));
 368                     }
 369                 }
 370             }
 371         }
 372     }
 373     catch( uno::Exception & ex )
 374     {
 375         ASSERT_EXCEPTION( ex );
 376     }
 377
 378     return bResult;
 379 }
 380
 381 Reference< chart2::XChartType > ColumnLineChartTypeTemplate::getChartTypeForIndex( sal_Int32 nChartTypeIndex )
 382 {
 383     Reference< chart2::XChartType > xCT;
 384     Reference< lang::XMultiServiceFactory > xFact(
 385             GetComponentContext()->getServiceManager(), uno::UNO_QUERY );
 386     if(xFact.is())
 387     {
 388         if( nChartTypeIndex == 0 )
 389             xCT.set( xFact->createInstance( CHART2_SERVICE_NAME_CHARTTYPE_COLUMN ), uno::UNO_QUERY );
 390         else
 391             xCT.set( xFact->createInstance( CHART2_SERVICE_NAME_CHARTTYPE_LINE ), uno::UNO_QUERY );
 392     }
 393     return xCT;
 394 }
 395
 396 Reference< XChartType > SAL_CALL ColumnLineChartTypeTemplate::getChartTypeForNewSeries(
 397         const uno::Sequence< Reference< chart2::XChartType > >& aFormerlyUsedChartTypes )
 398     throw (uno::RuntimeException)
 399 {
 400     Reference< chart2::XChartType > xResult;
 401
 402     try
 403     {
 404         Reference< lang::XMultiServiceFactory > xFact(
 405             GetComponentContext()->getServiceManager(), uno::UNO_QUERY_THROW );
 406         xResult.set( xFact->createInstance(
 407                          CHART2_SERVICE_NAME_CHARTTYPE_LINE ), uno::UNO_QUERY_THROW );
 408         ChartTypeTemplate::copyPropertiesFromOldToNewCoordianteSystem( aFormerlyUsedChartTypes, xResult );
 409     }
 410     catch( uno::Exception & ex )
 411     {
 412         ASSERT_EXCEPTION( ex );
 413     }
 414
 415     return xResult;
 416 }
 417
 418 Reference< XDataInterpreter > SAL_CALL ColumnLineChartTypeTemplate::getDataInterpreter()
 419     throw (uno::RuntimeException)
 420 {
 421     if( ! m_xDataInterpreter.is())
 422     {
 423         sal_Int32 nNumberOfLines = 1;
 424         getFastPropertyValue( PROP_COL_LINE_NUMBER_OF_LINES ) >>= nNumberOfLines;
 425         m_xDataInterpreter.set( new ColumnLineDataInterpreter( nNumberOfLines, GetComponentContext() ) );
 426     }
 427     else
 428     {
 429         //todo...
 430         OSL_ENSURE( false, "number of lines may not be valid anymore in the datainterpreter" );
 431
 432     }
 433
 434     return m_xDataInterpreter;
 435 }
 436
 437 // ----------------------------------------
 438
 439 uno::Sequence< ::rtl::OUString > ColumnLineChartTypeTemplate::getSupportedServiceNames_Static()
 440 {
 441     uno::Sequence< ::rtl::OUString > aServices( 2 );
 442     aServices[ 0 ] = lcl_aServiceName;
 443     aServices[ 1 ] = C2U( "com.sun.star.chart2.ChartTypeTemplate" );
 444     return aServices;
 445 }
 446
 447 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 448 APPHELPER_XSERVICEINFO_IMPL( ColumnLineChartTypeTemplate, lcl_aServiceName );
 449
 450 IMPLEMENT_FORWARD_XINTERFACE2( ColumnLineChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 451 IMPLEMENT_FORWARD_XTYPEPROVIDER2( ColumnLineChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 452
 453 } //  namespace chart