chart2/source/model/main/Diagram.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 <Diagram.hxx>
  21 #include <PropertyHelper.hxx>
  22 #include "Wall.hxx"
  23 #include <ModifyListenerHelper.hxx>
  24 #include <UserDefinedProperties.hxx>
  25 #include <ConfigColorScheme.hxx>
  26 #include <DiagramHelper.hxx>
  27 #include <ThreeDHelper.hxx>
  28 #include <CloneHelper.hxx>
  29 #include <SceneProperties.hxx>
  30 #include <unonames.hxx>
  31
  32 #include <basegfx/numeric/ftools.hxx>
  33 #include <rtl/instance.hxx>
  34 #include <com/sun/star/beans/PropertyAttribute.hpp>
  35 #include <com/sun/star/chart2/RelativePosition.hpp>
  36 #include <com/sun/star/chart2/RelativeSize.hpp>
  37 #include <com/sun/star/container/NoSuchElementException.hpp>
  38 #include <com/sun/star/uno/XComponentContext.hpp>
  39 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  40
  41 #include <cppuhelper/supportsservice.hxx>
  42 #include <tools/diagnose_ex.h>
  43
  44 #include <algorithm>
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::beans::PropertyAttribute;
  48
  49 using ::com::sun::star::beans::Property;
  50 using ::com::sun::star::uno::Sequence;
  51 using ::com::sun::star::uno::Reference;
  52 using ::com::sun::star::uno::Any;
  53 using ::osl::MutexGuard;
  54
  55 namespace
  56 {
  57
  58 enum
  59 {
  60     PROP_DIAGRAM_REL_POS,
  61     PROP_DIAGRAM_REL_SIZE,
  62     PROP_DIAGRAM_POSSIZE_EXCLUDE_LABELS,
  63     PROP_DIAGRAM_SORT_BY_X_VALUES,
  64     PROP_DIAGRAM_CONNECT_BARS,
  65     PROP_DIAGRAM_GROUP_BARS_PER_AXIS,
  66     PROP_DIAGRAM_INCLUDE_HIDDEN_CELLS,
  67     PROP_DIAGRAM_STARTING_ANGLE,
  68     PROP_DIAGRAM_RIGHT_ANGLED_AXES,
  69     PROP_DIAGRAM_PERSPECTIVE,
  70     PROP_DIAGRAM_ROTATION_HORIZONTAL,
  71     PROP_DIAGRAM_ROTATION_VERTICAL,
  72     PROP_DIAGRAM_MISSING_VALUE_TREATMENT,
  73     PROP_DIAGRAM_3DRELATIVEHEIGHT,
  74     PROP_DIAGRAM_DATATABLEHBORDER,
  75     PROP_DIAGRAM_DATATABLEVBORDER,
  76     PROP_DIAGRAM_DATATABLEOUTLINE,
  77     PROP_DIAGRAM_EXTERNALDATA
  78 };
  79
  80 void lcl_AddPropertiesToVector(
  81     std::vector< Property > & rOutProperties )
  82 {
  83     rOutProperties.emplace_back( "RelativePosition",
  84                   PROP_DIAGRAM_REL_POS,
  85                   cppu::UnoType<chart2::RelativePosition>::get(),
  86                   beans::PropertyAttribute::BOUND
  87                   | beans::PropertyAttribute::MAYBEVOID );
  88
  89     rOutProperties.emplace_back( "RelativeSize",
  90                   PROP_DIAGRAM_REL_SIZE,
  91                   cppu::UnoType<chart2::RelativeSize>::get(),
  92                   beans::PropertyAttribute::BOUND
  93                   | beans::PropertyAttribute::MAYBEVOID );
  94
  95     rOutProperties.emplace_back( "PosSizeExcludeAxes",
  96                   PROP_DIAGRAM_POSSIZE_EXCLUDE_LABELS,
  97                   cppu::UnoType<bool>::get(),
  98                   beans::PropertyAttribute::BOUND
  99                   | beans::PropertyAttribute::MAYBEDEFAULT );
 100
 101     rOutProperties.emplace_back( CHART_UNONAME_SORT_BY_XVALUES,
 102                   PROP_DIAGRAM_SORT_BY_X_VALUES,
 103                   cppu::UnoType<bool>::get(),
 104                   beans::PropertyAttribute::BOUND
 105                   | beans::PropertyAttribute::MAYBEDEFAULT );
 106
 107     rOutProperties.emplace_back( "ConnectBars",
 108                   PROP_DIAGRAM_CONNECT_BARS,
 109                   cppu::UnoType<bool>::get(),
 110                   beans::PropertyAttribute::BOUND
 111                   | beans::PropertyAttribute::MAYBEDEFAULT );
 112
 113     rOutProperties.emplace_back( "GroupBarsPerAxis",
 114                   PROP_DIAGRAM_GROUP_BARS_PER_AXIS,
 115                   cppu::UnoType<bool>::get(),
 116                   beans::PropertyAttribute::BOUND
 117                   | beans::PropertyAttribute::MAYBEDEFAULT );
 118
 119     rOutProperties.emplace_back( "IncludeHiddenCells",
 120                   PROP_DIAGRAM_INCLUDE_HIDDEN_CELLS,
 121                   cppu::UnoType<bool>::get(),
 122                   beans::PropertyAttribute::BOUND
 123                   | beans::PropertyAttribute::MAYBEDEFAULT );
 124
 125     rOutProperties.emplace_back( "StartingAngle",
 126                   PROP_DIAGRAM_STARTING_ANGLE,
 127                   cppu::UnoType<sal_Int32>::get(),
 128                   beans::PropertyAttribute::BOUND
 129                   | beans::PropertyAttribute::MAYBEDEFAULT );
 130
 131     rOutProperties.emplace_back( "RightAngledAxes",
 132                   PROP_DIAGRAM_RIGHT_ANGLED_AXES,
 133                   cppu::UnoType<bool>::get(),
 134                   beans::PropertyAttribute::BOUND
 135                   | beans::PropertyAttribute::MAYBEDEFAULT );
 136
 137     rOutProperties.emplace_back( "Perspective",
 138                   PROP_DIAGRAM_PERSPECTIVE,
 139                   cppu::UnoType<sal_Int32>::get(),
 140                   beans::PropertyAttribute::MAYBEVOID );
 141
 142     rOutProperties.emplace_back( "RotationHorizontal",
 143                   PROP_DIAGRAM_ROTATION_HORIZONTAL,
 144                   cppu::UnoType<sal_Int32>::get(),
 145                   beans::PropertyAttribute::MAYBEVOID );
 146
 147     rOutProperties.emplace_back( "RotationVertical",
 148                   PROP_DIAGRAM_ROTATION_VERTICAL,
 149                   cppu::UnoType<sal_Int32>::get(),
 150                   beans::PropertyAttribute::MAYBEVOID );
 151
 152     rOutProperties.emplace_back( "MissingValueTreatment",
 153                   PROP_DIAGRAM_MISSING_VALUE_TREATMENT,
 154                   cppu::UnoType<sal_Int32>::get(),
 155                   beans::PropertyAttribute::BOUND
 156                   | beans::PropertyAttribute::MAYBEVOID );
 157     rOutProperties.emplace_back( "3DRelativeHeight",
 158                   PROP_DIAGRAM_3DRELATIVEHEIGHT,
 159                   cppu::UnoType<sal_Int32>::get(),
 160                   beans::PropertyAttribute::MAYBEVOID );
 161     rOutProperties.emplace_back( "DataTableHBorder",
 162                PROP_DIAGRAM_DATATABLEHBORDER,
 163                  cppu::UnoType<bool>::get(),
 164                  beans::PropertyAttribute::BOUND
 165                  | beans::PropertyAttribute::MAYBEDEFAULT );
 166     rOutProperties.emplace_back( "DataTableVBorder",
 167                PROP_DIAGRAM_DATATABLEVBORDER,
 168                  cppu::UnoType<bool>::get(),
 169                  beans::PropertyAttribute::BOUND
 170                  | beans::PropertyAttribute::MAYBEDEFAULT );
 171     rOutProperties.emplace_back( "DataTableOutline",
 172                PROP_DIAGRAM_DATATABLEOUTLINE,
 173                  cppu::UnoType<bool>::get(),
 174                  beans::PropertyAttribute::BOUND
 175                  | beans::PropertyAttribute::MAYBEDEFAULT );
 176     rOutProperties.emplace_back( "ExternalData",
 177                   PROP_DIAGRAM_EXTERNALDATA,
 178                   cppu::UnoType<OUString>::get(),
 179                   beans::PropertyAttribute::MAYBEVOID );
 180 }
 181
 182 struct StaticDiagramDefaults_Initializer
 183 {
 184     ::chart::tPropertyValueMap* operator()()
 185     {
 186         static ::chart::tPropertyValueMap aStaticDefaults;
 187         lcl_AddDefaultsToMap( aStaticDefaults );
 188         return &aStaticDefaults;
 189     }
 190 private:
 191     static void lcl_AddDefaultsToMap( ::chart::tPropertyValueMap & rOutMap )
 192     {
 193         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_POSSIZE_EXCLUDE_LABELS, true );
 194         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_SORT_BY_X_VALUES, false );
 195         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_CONNECT_BARS, false );
 196         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_GROUP_BARS_PER_AXIS, true );
 197         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_INCLUDE_HIDDEN_CELLS, true );
 198         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_RIGHT_ANGLED_AXES, false );
 199         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_DATATABLEHBORDER, false );
 200         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_DATATABLEVBORDER, false );
 201         ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_DIAGRAM_DATATABLEOUTLINE, false );
 202         ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( rOutMap, PROP_DIAGRAM_STARTING_ANGLE, 90 );
 203         ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( rOutMap, PROP_DIAGRAM_3DRELATIVEHEIGHT, 100 );
 204         ::chart::SceneProperties::AddDefaultsToMap( rOutMap );
 205     }
 206 };
 207
 208 struct StaticDiagramDefaults : public rtl::StaticAggregate< ::chart::tPropertyValueMap, StaticDiagramDefaults_Initializer >
 209 {
 210 };
 211
 212 struct StaticDiagramInfoHelper_Initializer
 213 {
 214     ::cppu::OPropertyArrayHelper* operator()()
 215     {
 216         static ::cppu::OPropertyArrayHelper aPropHelper( lcl_GetPropertySequence() );
 217         return &aPropHelper;
 218     }
 219
 220 private:
 221     static Sequence< Property > lcl_GetPropertySequence()
 222     {
 223         std::vector< css::beans::Property > aProperties;
 224         lcl_AddPropertiesToVector( aProperties );
 225         ::chart::SceneProperties::AddPropertiesToVector( aProperties );
 226         ::chart::UserDefinedProperties::AddPropertiesToVector( aProperties );
 227
 228         std::sort( aProperties.begin(), aProperties.end(),
 229                      ::chart::PropertyNameLess() );
 230
 231         return comphelper::containerToSequence( aProperties );
 232     }
 233 };
 234
 235 struct StaticDiagramInfoHelper : public rtl::StaticAggregate< ::cppu::OPropertyArrayHelper, StaticDiagramInfoHelper_Initializer >
 236 {
 237 };
 238
 239 struct StaticDiagramInfo_Initializer
 240 {
 241     uno::Reference< beans::XPropertySetInfo >* operator()()
 242     {
 243         static uno::Reference< beans::XPropertySetInfo > xPropertySetInfo(
 244             ::cppu::OPropertySetHelper::createPropertySetInfo(*StaticDiagramInfoHelper::get() ) );
 245         return &xPropertySetInfo;
 246     }
 247 };
 248
 249 struct StaticDiagramInfo : public rtl::StaticAggregate< uno::Reference< beans::XPropertySetInfo >, StaticDiagramInfo_Initializer >
 250 {
 251 };
 252
 253 /// clones a UNO-sequence of UNO-References
 254 typedef Reference< chart2::XCoordinateSystem > lcl_tCooSysRef;
 255 typedef std::vector< lcl_tCooSysRef >          lcl_tCooSysVector;
 256
 257 void lcl_CloneCoordinateSystems(
 258         const lcl_tCooSysVector & rSource,
 259         lcl_tCooSysVector & rDestination )
 260 {
 261     for( auto const & i : rSource )
 262     {
 263         lcl_tCooSysRef xClone;
 264         css::uno::Reference< css::util::XCloneable > xCloneable( i, css::uno::UNO_QUERY );
 265         if( xCloneable.is())
 266             xClone.set( xCloneable->createClone(), css::uno::UNO_QUERY );
 267
 268         if( xClone.is())
 269         {
 270             rDestination.push_back( xClone );
 271         }
 272         else
 273             rDestination.push_back( i );
 274     }
 275 }
 276
 277 } // anonymous namespace
 278
 279 namespace chart
 280 {
 281
 282 Diagram::Diagram( uno::Reference< uno::XComponentContext > const & xContext ) :
 283         ::property::OPropertySet( m_aMutex ),
 284         m_xContext( xContext ),
 285         m_xModifyEventForwarder( ModifyListenerHelper::createModifyEventForwarder())
 286 {
 287     // Set camera position to a default position (that should be set hard, so
 288     // that it will be exported.  The property default is a camera looking
 289     // straight ono the scene).  These defaults have been acquired from the old
 290     // chart implementation.
 291     setFastPropertyValue_NoBroadcast(
 292         SceneProperties::PROP_SCENE_CAMERA_GEOMETRY, uno::Any(
 293             ThreeDHelper::getDefaultCameraGeometry()));
 294 }
 295
 296 Diagram::Diagram( const Diagram & rOther ) :
 297         impl::Diagram_Base(rOther),
 298         ::property::OPropertySet( rOther, m_aMutex ),
 299     m_xContext( rOther.m_xContext ),
 300     m_xModifyEventForwarder( ModifyListenerHelper::createModifyEventForwarder())
 301 {
 302     lcl_CloneCoordinateSystems( rOther.m_aCoordSystems, m_aCoordSystems );
 303     ModifyListenerHelper::addListenerToAllElements( m_aCoordSystems, m_xModifyEventForwarder );
 304
 305     m_xWall.set( CloneHelper::CreateRefClone< beans::XPropertySet >()( rOther.m_xWall ));
 306     m_xFloor.set( CloneHelper::CreateRefClone< beans::XPropertySet >()( rOther.m_xFloor ));
 307     m_xTitle.set( CloneHelper::CreateRefClone< chart2::XTitle >()( rOther.m_xTitle ));
 308     m_xLegend.set( CloneHelper::CreateRefClone< chart2::XLegend >()( rOther.m_xLegend ));
 309
 310     ModifyListenerHelper::addListener( m_xWall, m_xModifyEventForwarder );
 311     ModifyListenerHelper::addListener( m_xFloor, m_xModifyEventForwarder );
 312     ModifyListenerHelper::addListener( m_xTitle, m_xModifyEventForwarder );
 313     ModifyListenerHelper::addListener( m_xLegend, m_xModifyEventForwarder );
 314 }
 315
 316 Diagram::~Diagram()
 317 {
 318     try
 319     {
 320         ModifyListenerHelper::removeListenerFromAllElements( m_aCoordSystems, m_xModifyEventForwarder );
 321
 322         ModifyListenerHelper::removeListener( m_xWall, m_xModifyEventForwarder );
 323         ModifyListenerHelper::removeListener( m_xFloor, m_xModifyEventForwarder );
 324         ModifyListenerHelper::removeListener( m_xTitle, m_xModifyEventForwarder );
 325         ModifyListenerHelper::removeListener( m_xLegend, m_xModifyEventForwarder );
 326     }
 327     catch( const uno::Exception & )
 328     {
 329         DBG_UNHANDLED_EXCEPTION("chart2");
 330     }
 331 }
 332
 333 // ____ XDiagram ____
 334 uno::Reference< beans::XPropertySet > SAL_CALL Diagram::getWall()
 335 {
 336     uno::Reference< beans::XPropertySet > xRet;
 337     bool bAddListener = false;
 338     {
 339         MutexGuard aGuard( m_aMutex );
 340         if( !m_xWall.is() )
 341         {
 342             m_xWall.set( new Wall() );
 343             bAddListener = true;
 344         }
 345         xRet =  m_xWall;
 346     }
 347     if(bAddListener)
 348         ModifyListenerHelper::addListener( xRet, m_xModifyEventForwarder );
 349     return xRet;
 350 }
 351
 352 uno::Reference< beans::XPropertySet > SAL_CALL Diagram::getFloor()
 353 {
 354     uno::Reference< beans::XPropertySet > xRet;
 355     bool bAddListener = false;
 356     {
 357         MutexGuard aGuard( m_aMutex );
 358         if( !m_xFloor.is() )
 359         {
 360             m_xFloor.set( new Wall() );
 361             bAddListener = true;
 362         }
 363         xRet = m_xFloor;
 364     }
 365     if(bAddListener)
 366         ModifyListenerHelper::addListener( xRet, m_xModifyEventForwarder );
 367     return xRet;
 368 }
 369
 370 uno::Reference< chart2::XLegend > SAL_CALL Diagram::getLegend()
 371 {
 372     MutexGuard aGuard( m_aMutex );
 373     return m_xLegend;
 374 }
 375
 376 void SAL_CALL Diagram::setLegend( const uno::Reference< chart2::XLegend >& xNewLegend )
 377 {
 378     Reference< chart2::XLegend > xOldLegend;
 379     {
 380         MutexGuard aGuard( m_aMutex );
 381         if( m_xLegend == xNewLegend )
 382             return;
 383         xOldLegend = m_xLegend;
 384         m_xLegend = xNewLegend;
 385     }
 386     if( xOldLegend.is())
 387         ModifyListenerHelper::removeListener( xOldLegend, m_xModifyEventForwarder );
 388     if( xNewLegend.is())
 389         ModifyListenerHelper::addListener( xNewLegend, m_xModifyEventForwarder );
 390     fireModifyEvent();
 391 }
 392
 393 Reference< chart2::XColorScheme > SAL_CALL Diagram::getDefaultColorScheme()
 394 {
 395     Reference< chart2::XColorScheme > xRet;
 396     {
 397         MutexGuard aGuard( m_aMutex );
 398         xRet = m_xColorScheme;
 399     }
 400
 401     if( !xRet.is())
 402     {
 403         xRet.set( createConfigColorScheme( m_xContext ));
 404         MutexGuard aGuard( m_aMutex );
 405         m_xColorScheme = xRet;
 406     }
 407     return xRet;
 408 }
 409
 410 void SAL_CALL Diagram::setDefaultColorScheme( const Reference< chart2::XColorScheme >& xColorScheme )
 411 {
 412     {
 413         MutexGuard aGuard( m_aMutex );
 414         m_xColorScheme.set( xColorScheme );
 415     }
 416     fireModifyEvent();
 417 }
 418
 419 void SAL_CALL Diagram::setDiagramData(
 420     const Reference< chart2::data::XDataSource >& xDataSource,
 421     const Sequence< beans::PropertyValue >& aArguments )
 422 {
 423     uno::Reference< lang::XMultiServiceFactory > xChartTypeManager( m_xContext->getServiceManager()->createInstanceWithContext(
 424             "com.sun.star.chart2.ChartTypeManager", m_xContext ), uno::UNO_QUERY );
 425     DiagramHelper::tTemplateWithServiceName aTemplateAndService = DiagramHelper::getTemplateForDiagram( this, xChartTypeManager );
 426     uno::Reference< chart2::XChartTypeTemplate > xTemplate( aTemplateAndService.first );
 427     if( !xTemplate.is() )
 428         xTemplate.set( xChartTypeManager->createInstance( "com.sun.star.chart2.template.Column" ), uno::UNO_QUERY );
 429     if(!xTemplate.is())
 430         return;
 431     xTemplate->changeDiagramData( this, xDataSource, aArguments );
 432 }
 433
 434 // ____ XTitled ____
 435 uno::Reference< chart2::XTitle > SAL_CALL Diagram::getTitleObject()
 436 {
 437     MutexGuard aGuard( m_aMutex );
 438     return m_xTitle;
 439 }
 440
 441 void SAL_CALL Diagram::setTitleObject( const uno::Reference< chart2::XTitle >& xNewTitle )
 442 {
 443     Reference< chart2::XTitle > xOldTitle;
 444     {
 445         MutexGuard aGuard( m_aMutex );
 446         if( m_xTitle == xNewTitle )
 447             return;
 448         xOldTitle = m_xTitle;
 449         m_xTitle = xNewTitle;
 450     }
 451     if( xOldTitle.is())
 452         ModifyListenerHelper::removeListener( xOldTitle, m_xModifyEventForwarder );
 453     if( xNewTitle.is())
 454         ModifyListenerHelper::addListener( xNewTitle, m_xModifyEventForwarder );
 455     fireModifyEvent();
 456 }
 457
 458 // ____ X3DDefaultSetter ____
 459 void SAL_CALL Diagram::set3DSettingsToDefault()
 460 {
 461     ThreeDHelper::set3DSettingsToDefault( this );
 462 }
 463
 464 void SAL_CALL Diagram::setDefaultRotation()
 465 {
 466     ThreeDHelper::setDefaultRotation( this );
 467 }
 468
 469 void SAL_CALL Diagram::setDefaultIllumination()
 470 {
 471     ThreeDHelper::setDefaultIllumination( this );
 472 }
 473
 474 // ____ XCoordinateSystemContainer ____
 475 void SAL_CALL Diagram::addCoordinateSystem(
 476     const uno::Reference< chart2::XCoordinateSystem >& aCoordSys )
 477 {
 478     {
 479         MutexGuard aGuard( m_aMutex );
 480         if( std::find( m_aCoordSystems.begin(), m_aCoordSystems.end(), aCoordSys )
 481             != m_aCoordSystems.end())
 482             throw lang::IllegalArgumentException();
 483
 484         if( !m_aCoordSystems.empty() )
 485         {
 486             OSL_FAIL( "more than one coordinatesystem is not supported yet by the fileformat" );
 487             return;
 488         }
 489         m_aCoordSystems.push_back( aCoordSys );
 490     }
 491     ModifyListenerHelper::addListener( aCoordSys, m_xModifyEventForwarder );
 492     fireModifyEvent();
 493 }
 494
 495 void SAL_CALL Diagram::removeCoordinateSystem(
 496     const uno::Reference< chart2::XCoordinateSystem >& aCoordSys )
 497 {
 498     {
 499         MutexGuard aGuard( m_aMutex );
 500         std::vector< uno::Reference< chart2::XCoordinateSystem > >::iterator
 501               aIt( std::find( m_aCoordSystems.begin(), m_aCoordSystems.end(), aCoordSys ));
 502         if( aIt == m_aCoordSystems.end())
 503             throw container::NoSuchElementException(
 504                 "The given coordinate-system is no element of the container",
 505                 static_cast< uno::XWeak * >( this ));
 506         m_aCoordSystems.erase( aIt );
 507     }
 508     ModifyListenerHelper::removeListener( aCoordSys, m_xModifyEventForwarder );
 509     fireModifyEvent();
 510 }
 511
 512 uno::Sequence< uno::Reference< chart2::XCoordinateSystem > > SAL_CALL Diagram::getCoordinateSystems()
 513 {
 514     MutexGuard aGuard( m_aMutex );
 515     return comphelper::containerToSequence( m_aCoordSystems );
 516 }
 517
 518 void SAL_CALL Diagram::setCoordinateSystems(
 519     const Sequence< Reference< chart2::XCoordinateSystem > >& aCoordinateSystems )
 520 {
 521     tCoordinateSystemContainerType aNew;
 522     tCoordinateSystemContainerType aOld;
 523     if( aCoordinateSystems.hasElements() )
 524     {
 525         OSL_ENSURE( aCoordinateSystems.getLength()<=1, "more than one coordinatesystem is not supported yet by the fileformat" );
 526         aNew.push_back( aCoordinateSystems[0] );
 527     }
 528     {
 529         MutexGuard aGuard( m_aMutex );
 530         std::swap( aOld, m_aCoordSystems );
 531         m_aCoordSystems = aNew;
 532     }
 533     ModifyListenerHelper::removeListenerFromAllElements( aOld, m_xModifyEventForwarder );
 534     ModifyListenerHelper::addListenerToAllElements( aNew, m_xModifyEventForwarder );
 535     fireModifyEvent();
 536 }
 537
 538 // ____ XCloneable ____
 539 Reference< util::XCloneable > SAL_CALL Diagram::createClone()
 540 {
 541     MutexGuard aGuard( m_aMutex );
 542     return Reference< util::XCloneable >( new Diagram( *this ));
 543 }
 544
 545 // ____ XModifyBroadcaster ____
 546 void SAL_CALL Diagram::addModifyListener( const Reference< util::XModifyListener >& aListener )
 547 {
 548     try
 549     {
 550         Reference< util::XModifyBroadcaster > xBroadcaster( m_xModifyEventForwarder, uno::UNO_QUERY_THROW );
 551         xBroadcaster->addModifyListener( aListener );
 552     }
 553     catch( const uno::Exception & )
 554     {
 555         DBG_UNHANDLED_EXCEPTION("chart2");
 556     }
 557 }
 558
 559 void SAL_CALL Diagram::removeModifyListener( const Reference< util::XModifyListener >& aListener )
 560 {
 561     try
 562     {
 563         Reference< util::XModifyBroadcaster > xBroadcaster( m_xModifyEventForwarder, uno::UNO_QUERY_THROW );
 564         xBroadcaster->removeModifyListener( aListener );
 565     }
 566     catch( const uno::Exception & )
 567     {
 568         DBG_UNHANDLED_EXCEPTION("chart2");
 569     }
 570 }
 571
 572 // ____ XModifyListener ____
 573 void SAL_CALL Diagram::modified( const lang::EventObject& aEvent )
 574 {
 575     m_xModifyEventForwarder->modified( aEvent );
 576 }
 577
 578 // ____ XEventListener (base of XModifyListener) ____
 579 void SAL_CALL Diagram::disposing( const lang::EventObject& /* Source */ )
 580 {
 581     // nothing
 582 }
 583
 584 // ____ OPropertySet ____
 585 void Diagram::firePropertyChangeEvent()
 586 {
 587     fireModifyEvent();
 588 }
 589
 590 void Diagram::fireModifyEvent()
 591 {
 592     m_xModifyEventForwarder->modified( lang::EventObject( static_cast< uno::XWeak* >( this )));
 593 }
 594
 595 // ____ OPropertySet ____
 596 uno::Any Diagram::GetDefaultValue( sal_Int32 nHandle ) const
 597 {
 598     const tPropertyValueMap& rStaticDefaults = *StaticDiagramDefaults::get();
 599     tPropertyValueMap::const_iterator aFound( rStaticDefaults.find( nHandle ) );
 600     if( aFound == rStaticDefaults.end() )
 601         return uno::Any();
 602     return (*aFound).second;
 603 }
 604
 605 // ____ OPropertySet ____
 606 ::cppu::IPropertyArrayHelper & SAL_CALL Diagram::getInfoHelper()
 607 {
 608     return *StaticDiagramInfoHelper::get();
 609 }
 610
 611 // ____ XPropertySet ____
 612 uno::Reference< beans::XPropertySetInfo > SAL_CALL Diagram::getPropertySetInfo()
 613 {
 614     return *StaticDiagramInfo::get();
 615 }
 616
 617 // ____ XFastPropertySet ____
 618 void SAL_CALL Diagram::setFastPropertyValue( sal_Int32 nHandle, const Any& rValue )
 619 {
 620     //special treatment for some 3D properties
 621     if( nHandle == PROP_DIAGRAM_PERSPECTIVE )
 622     {
 623         sal_Int32 fPerspective = 20;
 624         if( rValue >>=fPerspective )
 625             ThreeDHelper::setCameraDistance( this, ThreeDHelper::PerspectiveToCameraDistance( fPerspective ) );
 626     }
 627     else if( nHandle == PROP_DIAGRAM_ROTATION_HORIZONTAL
 628         || nHandle == PROP_DIAGRAM_ROTATION_VERTICAL )
 629     {
 630         sal_Int32 nNewAngleDegree = 0;
 631         if( rValue >>=nNewAngleDegree )
 632         {
 633             sal_Int32 nHorizontal, nVertical;
 634             ThreeDHelper::getRotationFromDiagram( this, nHorizontal, nVertical );
 635             if( nHandle == PROP_DIAGRAM_ROTATION_HORIZONTAL )
 636                 nHorizontal = nNewAngleDegree;
 637             else
 638                 nVertical = nNewAngleDegree;
 639             ThreeDHelper::setRotationToDiagram( this, nHorizontal, nVertical );
 640         }
 641     }
 642     else
 643         ::property::OPropertySet::setFastPropertyValue( nHandle, rValue );
 644 }
 645
 646 void SAL_CALL Diagram::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 647 {
 648     //special treatment for some 3D properties
 649     if( nHandle == PROP_DIAGRAM_PERSPECTIVE )
 650     {
 651         sal_Int32 nPerspective = ::basegfx::fround( ThreeDHelper::CameraDistanceToPerspective(
 652             ThreeDHelper::getCameraDistance( const_cast< Diagram* >( this ) ) ) );
 653         rValue <<= nPerspective;
 654     }
 655     else if( nHandle == PROP_DIAGRAM_ROTATION_HORIZONTAL
 656         || nHandle == PROP_DIAGRAM_ROTATION_VERTICAL )
 657     {
 658         sal_Int32 nHorizontal, nVertical;
 659         ThreeDHelper::getRotationFromDiagram( const_cast< Diagram* >( this ), nHorizontal, nVertical );
 660         sal_Int32 nAngleDegree = 0;
 661         if( nHandle == PROP_DIAGRAM_ROTATION_HORIZONTAL )
 662             nAngleDegree = nHorizontal;
 663         else
 664             nAngleDegree = nVertical;
 665         rValue <<= nAngleDegree;
 666     }
 667     else
 668         ::property::OPropertySet::getFastPropertyValue( rValue,nHandle );
 669 }
 670
 671 using impl::Diagram_Base;
 672
 673 IMPLEMENT_FORWARD_XINTERFACE2( Diagram, Diagram_Base, ::property::OPropertySet )
 674 IMPLEMENT_FORWARD_XTYPEPROVIDER2( Diagram, Diagram_Base, ::property::OPropertySet )
 675
 676 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 677 OUString SAL_CALL Diagram::getImplementationName()
 678 {
 679     return "com.sun.star.comp.chart2.Diagram";
 680 }
 681
 682 sal_Bool SAL_CALL Diagram::supportsService( const OUString& rServiceName )
 683 {
 684     return cppu::supportsService(this, rServiceName);
 685 }
 686
 687 css::uno::Sequence< OUString > SAL_CALL Diagram::getSupportedServiceNames()
 688 {
 689     return {
 690         "com.sun.star.chart2.Diagram",
 691         "com.sun.star.layout.LayoutElement",
 692         "com.sun.star.beans.PropertySet" };
 693 }
 694
 695 } //  namespace chart
 696
 697 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 698 com_sun_star_comp_chart2_Diagram_get_implementation(css::uno::XComponentContext *context,
 699         css::uno::Sequence<css::uno::Any> const &)
 700 {
 701     return cppu::acquire(new ::chart::Diagram(context));
 702 }
 703
 704 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */