chart2/source/model/main/DataSeries.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 "DataSeries.hxx"
  21 #include "DataSeriesProperties.hxx"
  22 #include "DataPointProperties.hxx"
  23 #include "CharacterProperties.hxx"
  24 #include "UserDefinedProperties.hxx"
  25 #include "DataPoint.hxx"
  26 #include "macros.hxx"
  27 #include "DataSeriesHelper.hxx"
  28 #include "ContainerHelper.hxx"
  29 #include "CloneHelper.hxx"
  30 #include "ModifyListenerHelper.hxx"
  31 #include "EventListenerHelper.hxx"
  32
  33 #include <algorithm>
  34
  35 using namespace ::com::sun::star;
  36
  37 using ::com::sun::star::beans::Property;
  38 using ::com::sun::star::uno::Sequence;
  39 using ::com::sun::star::uno::Reference;
  40 using ::com::sun::star::uno::Any;
  41 using ::osl::MutexGuard;
  42
  43 // ----------------------------------------
  44
  45 namespace
  46 {
  47
  48 struct StaticDataSeriesDefaults_Initializer
  49 {
  50     ::chart::tPropertyValueMap* operator()()
  51     {
  52         static ::chart::tPropertyValueMap aStaticDefaults;
  53         lcl_AddDefaultsToMap( aStaticDefaults );
  54         return &aStaticDefaults;
  55     }
  56 private:
  57     void lcl_AddDefaultsToMap( ::chart::tPropertyValueMap & rOutMap )
  58     {
  59         ::chart::DataSeriesProperties::AddDefaultsToMap( rOutMap );
  60         ::chart::CharacterProperties::AddDefaultsToMap( rOutMap );
  61
  62         float fDefaultCharHeight = 10.0;
  63         ::chart::PropertyHelper::setPropertyValue( rOutMap, ::chart::CharacterProperties::PROP_CHAR_CHAR_HEIGHT, fDefaultCharHeight );
  64         ::chart::PropertyHelper::setPropertyValue( rOutMap, ::chart::CharacterProperties::PROP_CHAR_ASIAN_CHAR_HEIGHT, fDefaultCharHeight );
  65         ::chart::PropertyHelper::setPropertyValue( rOutMap, ::chart::CharacterProperties::PROP_CHAR_COMPLEX_CHAR_HEIGHT, fDefaultCharHeight );
  66     }
  67 };
  68
  69 struct StaticDataSeriesDefaults : public rtl::StaticAggregate< ::chart::tPropertyValueMap, StaticDataSeriesDefaults_Initializer >
  70 {
  71 };
  72
  73 struct StaticDataSeriesInfoHelper_Initializer
  74 {
  75     ::cppu::OPropertyArrayHelper* operator()()
  76     {
  77         static ::cppu::OPropertyArrayHelper aPropHelper( lcl_GetPropertySequence() );
  78         return &aPropHelper;
  79     }
  80
  81 private:
  82     uno::Sequence< Property > lcl_GetPropertySequence()
  83     {
  84         ::std::vector< ::com::sun::star::beans::Property > aProperties;
  85         ::chart::DataSeriesProperties::AddPropertiesToVector( aProperties );
  86         ::chart::CharacterProperties::AddPropertiesToVector( aProperties );
  87         ::chart::UserDefinedProperties::AddPropertiesToVector( aProperties );
  88
  89         ::std::sort( aProperties.begin(), aProperties.end(),
  90                      ::chart::PropertyNameLess() );
  91
  92         return ::chart::ContainerHelper::ContainerToSequence( aProperties );
  93     }
  94
  95 };
  96
  97 struct StaticDataSeriesInfoHelper : public rtl::StaticAggregate< ::cppu::OPropertyArrayHelper, StaticDataSeriesInfoHelper_Initializer >
  98 {
  99 };
 100
 101 struct StaticDataSeriesInfo_Initializer
 102 {
 103     uno::Reference< beans::XPropertySetInfo >* operator()()
 104     {
 105         static uno::Reference< beans::XPropertySetInfo > xPropertySetInfo(
 106             ::cppu::OPropertySetHelper::createPropertySetInfo(*StaticDataSeriesInfoHelper::get() ) );
 107         return &xPropertySetInfo;
 108     }
 109 };
 110
 111 struct StaticDataSeriesInfo : public rtl::StaticAggregate< uno::Reference< beans::XPropertySetInfo >, StaticDataSeriesInfo_Initializer >
 112 {
 113 };
 114
 115 void lcl_SetParent(
 116     const uno::Reference< uno::XInterface > & xChildInterface,
 117     const uno::Reference< uno::XInterface > & xParentInterface )
 118 {
 119     uno::Reference< container::XChild > xChild( xChildInterface, uno::UNO_QUERY );
 120     if( xChild.is())
 121         xChild->setParent( xParentInterface );
 122 }
 123
 124 typedef ::std::map< sal_Int32, ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > >
 125     lcl_tDataPointMap;
 126
 127 void lcl_CloneAttributedDataPoints(
 128     const lcl_tDataPointMap & rSource, lcl_tDataPointMap & rDestination,
 129     const uno::Reference< uno::XInterface > & xSeries )
 130 {
 131     for( lcl_tDataPointMap::const_iterator aIt( rSource.begin());
 132          aIt != rSource.end(); ++aIt )
 133     {
 134         Reference< beans::XPropertySet > xPoint( (*aIt).second );
 135         if( xPoint.is())
 136         {
 137             Reference< util::XCloneable > xCloneable( xPoint, uno::UNO_QUERY );
 138             if( xCloneable.is())
 139             {
 140                 xPoint.set( xCloneable->createClone(), uno::UNO_QUERY );
 141                 if( xPoint.is())
 142                 {
 143                     lcl_SetParent( xPoint, xSeries );
 144                     rDestination.insert( lcl_tDataPointMap::value_type( (*aIt).first, xPoint ));
 145                 }
 146             }
 147         }
 148     }
 149 }
 150
 151 } // anonymous namespace
 152
 153 // ----------------------------------------
 154
 155 namespace chart
 156 {
 157
 158 DataSeries::DataSeries( const uno::Reference< uno::XComponentContext > & xContext ) :
 159         ::property::OPropertySet( m_aMutex ),
 160         m_xContext( xContext ),
 161         m_xModifyEventForwarder( ModifyListenerHelper::createModifyEventForwarder())
 162 {
 163 }
 164
 165 DataSeries::DataSeries( const DataSeries & rOther ) :
 166         MutexContainer(),
 167         impl::DataSeries_Base(),
 168         ::property::OPropertySet( rOther, m_aMutex ),
 169     m_xContext( rOther.m_xContext ),
 170     m_xModifyEventForwarder( ModifyListenerHelper::createModifyEventForwarder())
 171 {
 172     if( ! rOther.m_aDataSequences.empty())
 173     {
 174         CloneHelper::CloneRefVector< tDataSequenceContainer::value_type >(
 175             rOther.m_aDataSequences, m_aDataSequences );
 176         ModifyListenerHelper::addListenerToAllElements( m_aDataSequences, m_xModifyEventForwarder );
 177     }
 178
 179     CloneHelper::CloneRefVector< Reference< chart2::XRegressionCurve > >( rOther.m_aRegressionCurves, m_aRegressionCurves );
 180     ModifyListenerHelper::addListenerToAllElements( m_aRegressionCurves, m_xModifyEventForwarder );
 181
 182     // add as listener to XPropertySet properties
 183     Reference< beans::XPropertySet > xPropertySet;
 184     uno::Any aValue;
 185
 186     getFastPropertyValue( aValue, DataPointProperties::PROP_DATAPOINT_ERROR_BAR_X );
 187     if( ( aValue >>= xPropertySet )
 188         && xPropertySet.is())
 189         ModifyListenerHelper::addListener( xPropertySet, m_xModifyEventForwarder );
 190
 191     getFastPropertyValue( aValue, DataPointProperties::PROP_DATAPOINT_ERROR_BAR_Y );
 192     if( ( aValue >>= xPropertySet )
 193         && xPropertySet.is())
 194         ModifyListenerHelper::addListener( xPropertySet, m_xModifyEventForwarder );
 195 }
 196
 197 // late initialization to call after copy-constructing
 198 void DataSeries::Init( const DataSeries & rOther )
 199 {
 200     if( ! rOther.m_aDataSequences.empty())
 201         EventListenerHelper::addListenerToAllElements( m_aDataSequences, this );
 202
 203     Reference< uno::XInterface > xThisInterface( static_cast< ::cppu::OWeakObject * >( this ));
 204     if( ! rOther.m_aAttributedDataPoints.empty())
 205     {
 206         lcl_CloneAttributedDataPoints(
 207             rOther.m_aAttributedDataPoints, m_aAttributedDataPoints, xThisInterface );
 208         ModifyListenerHelper::addListenerToAllMapElements( m_aAttributedDataPoints, m_xModifyEventForwarder );
 209     }
 210
 211     // add as parent to error bars
 212     Reference< beans::XPropertySet > xPropertySet;
 213     uno::Any aValue;
 214
 215     getFastPropertyValue( aValue, DataPointProperties::PROP_DATAPOINT_ERROR_BAR_X );
 216     if( ( aValue >>= xPropertySet )
 217         && xPropertySet.is())
 218         lcl_SetParent( xPropertySet, xThisInterface );
 219
 220     getFastPropertyValue( aValue, DataPointProperties::PROP_DATAPOINT_ERROR_BAR_Y );
 221     if( ( aValue >>= xPropertySet )
 222         && xPropertySet.is())
 223         lcl_SetParent( xPropertySet, xThisInterface );
 224 }
 225
 226 DataSeries::~DataSeries()
 227 {
 228     try
 229     {
 230         ModifyListenerHelper::removeListenerFromAllMapElements( m_aAttributedDataPoints, m_xModifyEventForwarder );
 231         ModifyListenerHelper::removeListenerFromAllElements( m_aRegressionCurves, m_xModifyEventForwarder );
 232         ModifyListenerHelper::removeListenerFromAllElements( m_aDataSequences, m_xModifyEventForwarder );
 233
 234         // remove listener from XPropertySet properties
 235         Reference< beans::XPropertySet > xPropertySet;
 236         uno::Any aValue;
 237
 238         getFastPropertyValue( aValue, DataPointProperties::PROP_DATAPOINT_ERROR_BAR_X );
 239         if( ( aValue >>= xPropertySet )
 240             && xPropertySet.is())
 241             ModifyListenerHelper::removeListener( xPropertySet, m_xModifyEventForwarder );
 242
 243         getFastPropertyValue( aValue, DataPointProperties::PROP_DATAPOINT_ERROR_BAR_Y );
 244         if( ( aValue >>= xPropertySet )
 245             && xPropertySet.is())
 246             ModifyListenerHelper::removeListener( xPropertySet, m_xModifyEventForwarder );
 247     }
 248     catch( const uno::Exception & ex )
 249     {
 250         ASSERT_EXCEPTION( ex );
 251     }
 252 }
 253
 254 // ____ XCloneable ____
 255 uno::Reference< util::XCloneable > SAL_CALL DataSeries::createClone()
 256     throw (uno::RuntimeException)
 257 {
 258     DataSeries * pNewSeries( new DataSeries( *this ));
 259     // hold a reference to the clone
 260     uno::Reference< util::XCloneable > xResult( pNewSeries );
 261     // do initialization that uses uno references to the clone
 262     pNewSeries->Init( *this );
 263
 264     return xResult;
 265 }
 266
 267 Sequence< OUString > DataSeries::getSupportedServiceNames_Static()
 268 {
 269     Sequence< OUString > aServices( 3 );
 270     aServices[ 0 ] = "com.sun.star.chart2.DataSeries";
 271     aServices[ 1 ] = "com.sun.star.chart2.DataPointProperties";
 272     aServices[ 2 ] = "com.sun.star.beans.PropertySet";
 273     return aServices;
 274 }
 275
 276 // ____ OPropertySet ____
 277 uno::Any DataSeries::GetDefaultValue( sal_Int32 nHandle ) const
 278     throw(beans::UnknownPropertyException)
 279 {
 280     const tPropertyValueMap& rStaticDefaults = *StaticDataSeriesDefaults::get();
 281     tPropertyValueMap::const_iterator aFound( rStaticDefaults.find( nHandle ) );
 282     if( aFound == rStaticDefaults.end() )
 283         return uno::Any();
 284     return (*aFound).second;
 285 }
 286
 287 // ____ OPropertySet ____
 288 ::cppu::IPropertyArrayHelper & SAL_CALL DataSeries::getInfoHelper()
 289 {
 290     return *StaticDataSeriesInfoHelper::get();
 291 }
 292
 293 // ____ XPropertySet ____
 294 uno::Reference< beans::XPropertySetInfo > SAL_CALL DataSeries::getPropertySetInfo()
 295     throw (uno::RuntimeException)
 296 {
 297     return *StaticDataSeriesInfo::get();
 298 }
 299
 300 void SAL_CALL DataSeries::getFastPropertyValue
 301     ( uno::Any& rValue,
 302       sal_Int32 nHandle ) const
 303 {
 304     // special handling for get.  set is not possible for this property
 305     if( nHandle == DataSeriesProperties::PROP_DATASERIES_ATTRIBUTED_DATA_POINTS )
 306     {
 307         // ToDo: only add those property sets that are really modified
 308         uno::Sequence< sal_Int32 > aSeq( m_aAttributedDataPoints.size());
 309         sal_Int32 * pIndexArray = aSeq.getArray();
 310         sal_Int32 i = 0;
 311
 312         for( tDataPointAttributeContainer::const_iterator aIt( m_aAttributedDataPoints.begin());
 313              aIt != m_aAttributedDataPoints.end(); ++aIt )
 314         {
 315             pIndexArray[ i ] = (*aIt).first;
 316             ++i;
 317         }
 318
 319         rValue <<= aSeq;
 320     }
 321     else
 322         OPropertySet::getFastPropertyValue( rValue, nHandle );
 323 }
 324
 325 void SAL_CALL DataSeries::setFastPropertyValue_NoBroadcast(
 326     sal_Int32 nHandle, const uno::Any& rValue )
 327     throw (uno::Exception)
 328 {
 329     if(    nHandle == DataPointProperties::PROP_DATAPOINT_ERROR_BAR_Y
 330         || nHandle == DataPointProperties::PROP_DATAPOINT_ERROR_BAR_X )
 331     {
 332         uno::Any aOldValue;
 333         Reference< util::XModifyBroadcaster > xBroadcaster;
 334         this->getFastPropertyValue( aOldValue, nHandle );
 335         if( aOldValue.hasValue() &&
 336             (aOldValue >>= xBroadcaster) &&
 337             xBroadcaster.is())
 338         {
 339             ModifyListenerHelper::removeListener( xBroadcaster, m_xModifyEventForwarder );
 340         }
 341
 342         OSL_ASSERT( rValue.getValueType().getTypeClass() == uno::TypeClass_INTERFACE );
 343         if( rValue.hasValue() &&
 344             (rValue >>= xBroadcaster) &&
 345             xBroadcaster.is())
 346         {
 347             ModifyListenerHelper::addListener( xBroadcaster, m_xModifyEventForwarder );
 348         }
 349     }
 350
 351     ::property::OPropertySet::setFastPropertyValue_NoBroadcast( nHandle, rValue );
 352 }
 353
 354 Reference< beans::XPropertySet >
 355     SAL_CALL DataSeries::getDataPointByIndex( sal_Int32 nIndex )
 356     throw (lang::IndexOutOfBoundsException,
 357            uno::RuntimeException)
 358 {
 359     Reference< beans::XPropertySet > xResult;
 360
 361     Sequence< Reference< chart2::data::XLabeledDataSequence > > aSequences;
 362     {
 363         MutexGuard aGuard( GetMutex() );
 364         aSequences = ContainerHelper::ContainerToSequence( m_aDataSequences );
 365     }
 366
 367     ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aValuesSeries(
 368         DataSeriesHelper::getAllDataSequencesByRole( aSequences , "values", true ) );
 369     if( !aValuesSeries.empty() )
 370     {
 371         Reference< chart2::data::XDataSequence > xSeq( aValuesSeries.front()->getValues() );
 372         if( 0 <= nIndex && nIndex < xSeq->getData().getLength() )
 373         {
 374             {
 375                 MutexGuard aGuard( GetMutex() );
 376                 tDataPointAttributeContainer::iterator aIt( m_aAttributedDataPoints.find( nIndex ) );
 377                 if( aIt != m_aAttributedDataPoints.end() )
 378                     xResult = (*aIt).second;
 379             }
 380             if( !xResult.is() )
 381             {
 382                 Reference< beans::XPropertySet > xParentProperties;
 383                 Reference< util::XModifyListener > xModifyEventForwarder;
 384                 {
 385                     MutexGuard aGuard( GetMutex() );
 386                     xParentProperties = this;
 387                     xModifyEventForwarder = m_xModifyEventForwarder;
 388                 }
 389
 390                 // create a new XPropertySet for this data point
 391                 xResult.set( new DataPoint( xParentProperties ) );
 392                 {
 393                     MutexGuard aGuard( GetMutex() );
 394                     m_aAttributedDataPoints[ nIndex ] = xResult;
 395                 }
 396                 ModifyListenerHelper::addListener( xResult, xModifyEventForwarder );
 397             }
 398         }
 399     }
 400     else
 401     {
 402         throw lang::IndexOutOfBoundsException();
 403     }
 404
 405     return xResult;
 406 }
 407
 408 void SAL_CALL DataSeries::resetDataPoint( sal_Int32 nIndex )
 409         throw (uno::RuntimeException)
 410 {
 411     Reference< beans::XPropertySet > xDataPointProp;
 412     Reference< util::XModifyListener > xModifyEventForwarder;
 413     {
 414         MutexGuard aGuard( GetMutex() );
 415         xModifyEventForwarder = m_xModifyEventForwarder;
 416         tDataPointAttributeContainer::iterator aIt( m_aAttributedDataPoints.find( nIndex ));
 417         if( aIt != m_aAttributedDataPoints.end())
 418         {
 419             xDataPointProp = (*aIt).second;
 420             m_aAttributedDataPoints.erase(aIt);
 421         }
 422
 423     }
 424     if( xDataPointProp.is() )
 425     {
 426         Reference< util::XModifyBroadcaster > xBroadcaster( xDataPointProp, uno::UNO_QUERY );
 427         if( xBroadcaster.is() && xModifyEventForwarder.is())
 428             xBroadcaster->removeModifyListener( xModifyEventForwarder );
 429         fireModifyEvent();
 430     }
 431 }
 432
 433 void SAL_CALL DataSeries::resetAllDataPoints()
 434         throw (uno::RuntimeException)
 435 {
 436     tDataPointAttributeContainer  aOldAttributedDataPoints;
 437     Reference< util::XModifyListener > xModifyEventForwarder;
 438     {
 439         MutexGuard aGuard( GetMutex() );
 440         xModifyEventForwarder = m_xModifyEventForwarder;
 441         std::swap( aOldAttributedDataPoints, m_aAttributedDataPoints );
 442     }
 443     ModifyListenerHelper::removeListenerFromAllMapElements( aOldAttributedDataPoints, xModifyEventForwarder );
 444     aOldAttributedDataPoints.clear();
 445     fireModifyEvent();
 446 }
 447
 448 // ____ XDataSink ____
 449 void SAL_CALL DataSeries::setData( const uno::Sequence< Reference< chart2::data::XLabeledDataSequence > >& aData )
 450     throw (uno::RuntimeException)
 451 {
 452     tDataSequenceContainer aOldDataSequences;
 453     tDataSequenceContainer aNewDataSequences;
 454     Reference< util::XModifyListener > xModifyEventForwarder;
 455     Reference< lang::XEventListener > xListener;
 456     {
 457         MutexGuard aGuard( GetMutex() );
 458         xModifyEventForwarder = m_xModifyEventForwarder;
 459         xListener = this;
 460         std::swap( aOldDataSequences, m_aDataSequences );
 461         aNewDataSequences = ContainerHelper::SequenceToVector( aData );
 462         m_aDataSequences = aNewDataSequences;
 463     }
 464     ModifyListenerHelper::removeListenerFromAllElements( aOldDataSequences, xModifyEventForwarder );
 465     EventListenerHelper::removeListenerFromAllElements( aOldDataSequences, xListener );
 466     EventListenerHelper::addListenerToAllElements( aNewDataSequences, xListener );
 467     ModifyListenerHelper::addListenerToAllElements( aNewDataSequences, xModifyEventForwarder );
 468     fireModifyEvent();
 469 }
 470
 471 // ____ XDataSource ____
 472 Sequence< Reference< chart2::data::XLabeledDataSequence > > SAL_CALL DataSeries::getDataSequences()
 473     throw (uno::RuntimeException)
 474 {
 475     MutexGuard aGuard( GetMutex() );
 476     return ContainerHelper::ContainerToSequence( m_aDataSequences );
 477 }
 478
 479
 480 // ____ XRegressionCurveContainer ____
 481 void SAL_CALL DataSeries::addRegressionCurve(
 482     const uno::Reference< chart2::XRegressionCurve >& xRegressionCurve )
 483     throw (lang::IllegalArgumentException,
 484            uno::RuntimeException)
 485 {
 486     Reference< util::XModifyListener > xModifyEventForwarder;
 487     {
 488         MutexGuard aGuard( GetMutex() );
 489         xModifyEventForwarder = m_xModifyEventForwarder;
 490         if( ::std::find( m_aRegressionCurves.begin(), m_aRegressionCurves.end(), xRegressionCurve )
 491             != m_aRegressionCurves.end())
 492             throw lang::IllegalArgumentException();
 493         m_aRegressionCurves.push_back( xRegressionCurve );
 494     }
 495     ModifyListenerHelper::addListener( xRegressionCurve, xModifyEventForwarder );
 496     fireModifyEvent();
 497 }
 498
 499 void SAL_CALL DataSeries::removeRegressionCurve(
 500     const uno::Reference< chart2::XRegressionCurve >& xRegressionCurve )
 501     throw (container::NoSuchElementException,
 502            uno::RuntimeException)
 503 {
 504     if( !xRegressionCurve.is() )
 505         throw container::NoSuchElementException();
 506
 507     Reference< util::XModifyListener > xModifyEventForwarder;
 508     {
 509         MutexGuard aGuard( GetMutex() );
 510         xModifyEventForwarder = m_xModifyEventForwarder;
 511         tRegressionCurveContainerType::iterator aIt(
 512             ::std::find( m_aRegressionCurves.begin(), m_aRegressionCurves.end(), xRegressionCurve ) );
 513         if( aIt == m_aRegressionCurves.end())
 514             throw container::NoSuchElementException(
 515                 "The given regression curve is no element of this series",
 516                 static_cast< uno::XWeak * >( this ));
 517         m_aRegressionCurves.erase( aIt );
 518     }
 519
 520     ModifyListenerHelper::removeListener( xRegressionCurve, xModifyEventForwarder );
 521     fireModifyEvent();
 522 }
 523
 524 uno::Sequence< uno::Reference< chart2::XRegressionCurve > > SAL_CALL DataSeries::getRegressionCurves()
 525     throw (uno::RuntimeException)
 526 {
 527     MutexGuard aGuard( GetMutex() );
 528     return ContainerHelper::ContainerToSequence( m_aRegressionCurves );
 529 }
 530
 531 void SAL_CALL DataSeries::setRegressionCurves(
 532     const Sequence< Reference< chart2::XRegressionCurve > >& aRegressionCurves )
 533     throw (uno::RuntimeException)
 534 {
 535     tRegressionCurveContainerType aOldCurves;
 536     tRegressionCurveContainerType aNewCurves( ContainerHelper::SequenceToVector( aRegressionCurves ) );
 537     Reference< util::XModifyListener > xModifyEventForwarder;
 538     {
 539         MutexGuard aGuard( GetMutex() );
 540         xModifyEventForwarder = m_xModifyEventForwarder;
 541         std::swap( aOldCurves, m_aRegressionCurves );
 542         m_aRegressionCurves = aNewCurves;
 543     }
 544     ModifyListenerHelper::removeListenerFromAllElements( aOldCurves, xModifyEventForwarder );
 545     ModifyListenerHelper::addListenerToAllElements( aNewCurves, xModifyEventForwarder );
 546     fireModifyEvent();
 547 }
 548
 549 // ____ XModifyBroadcaster ____
 550 void SAL_CALL DataSeries::addModifyListener( const Reference< util::XModifyListener >& aListener )
 551     throw (uno::RuntimeException)
 552 {
 553     try
 554     {
 555         Reference< util::XModifyBroadcaster > xBroadcaster( m_xModifyEventForwarder, uno::UNO_QUERY_THROW );
 556         xBroadcaster->addModifyListener( aListener );
 557     }
 558     catch( const uno::Exception & ex )
 559     {
 560         ASSERT_EXCEPTION( ex );
 561     }
 562 }
 563
 564 void SAL_CALL DataSeries::removeModifyListener( const Reference< util::XModifyListener >& aListener )
 565     throw (uno::RuntimeException)
 566 {
 567     try
 568     {
 569         Reference< util::XModifyBroadcaster > xBroadcaster( m_xModifyEventForwarder, uno::UNO_QUERY_THROW );
 570         xBroadcaster->removeModifyListener( aListener );
 571     }
 572     catch( const uno::Exception & ex )
 573     {
 574         ASSERT_EXCEPTION( ex );
 575     }
 576 }
 577
 578 // ____ XModifyListener ____
 579 void SAL_CALL DataSeries::modified( const lang::EventObject& aEvent )
 580     throw (uno::RuntimeException)
 581 {
 582     m_xModifyEventForwarder->modified( aEvent );
 583 }
 584
 585 // ____ XEventListener (base of XModifyListener) ____
 586 void SAL_CALL DataSeries::disposing( const lang::EventObject& rEventObject )
 587     throw (uno::RuntimeException)
 588 {
 589     // forget disposed data sequences
 590     tDataSequenceContainer::iterator aIt(
 591         ::std::find( m_aDataSequences.begin(), m_aDataSequences.end(), rEventObject.Source ));
 592     if( aIt != m_aDataSequences.end())
 593         m_aDataSequences.erase( aIt );
 594 }
 595
 596 // ____ OPropertySet ____
 597 void DataSeries::firePropertyChangeEvent()
 598 {
 599     fireModifyEvent();
 600 }
 601
 602 void DataSeries::fireModifyEvent()
 603 {
 604     m_xModifyEventForwarder->modified( lang::EventObject( static_cast< uno::XWeak* >( this )));
 605 }
 606
 607
 608 // ================================================================================
 609
 610 using impl::DataSeries_Base;
 611 using ::property::OPropertySet;
 612
 613 IMPLEMENT_FORWARD_XINTERFACE2( DataSeries, DataSeries_Base, OPropertySet )
 614 IMPLEMENT_FORWARD_XTYPEPROVIDER2( DataSeries, DataSeries_Base, OPropertySet )
 615
 616 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 617 APPHELPER_XSERVICEINFO_IMPL( DataSeries,
 618                              OUString("com.sun.star.comp.chart.DataSeries") );
 619
 620 }  // namespace chart
 621
 622 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */