chart2/source/model/template/PieChartTypeTemplate.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PieChartTypeTemplate.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33 #include "PieChartTypeTemplate.hxx"
  34 #include "macros.hxx"
  35 #include "CommonConverters.hxx"
  36 #include "DiagramHelper.hxx"
  37 #include "servicenames_charttypes.hxx"
  38 #include "DataSeriesHelper.hxx"
  39 #include "ContainerHelper.hxx"
  40 #include "BaseGFXHelper.hxx"
  41 #include "AxisHelper.hxx"
  42 #include "ThreeDHelper.hxx"
  43 #include "PropertyHelper.hxx"
  44 #include <com/sun/star/beans/PropertyAttribute.hpp>
  45 #include <com/sun/star/drawing/LineStyle.hpp>
  46 #include <com/sun/star/drawing/FillStyle.hpp>
  47 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  48 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  49
  50 #include <rtl/math.hxx>
  51
  52 #include <algorithm>
  53
  54 using namespace ::com::sun::star;
  55
  56 using ::rtl::OUString;
  57 using ::com::sun::star::beans::Property;
  58 using ::com::sun::star::uno::Sequence;
  59 using ::com::sun::star::uno::Reference;
  60 using ::com::sun::star::uno::Any;
  61 using ::osl::MutexGuard;
  62
  63 namespace
  64 {
  65
  66 static const ::rtl::OUString lcl_aServiceName(
  67     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.PieChartTypeTemplate" ));
  68
  69 enum
  70 {
  71     PROP_PIE_TEMPLATE_DEFAULT_OFFSET,
  72     PROP_PIE_TEMPLATE_OFFSET_MODE,
  73     PROP_PIE_TEMPLATE_DIMENSION,
  74     PROP_PIE_TEMPLATE_USE_RINGS
  75 };
  76
  77 void lcl_AddPropertiesToVector(
  78     ::std::vector< Property > & rOutProperties )
  79 {
  80     rOutProperties.push_back(
  81         Property( C2U( "OffsetMode" ),
  82                   PROP_PIE_TEMPLATE_OFFSET_MODE,
  83                   ::getCppuType( reinterpret_cast< const chart2::PieChartOffsetMode * >(0)),
  84                   beans::PropertyAttribute::BOUND
  85                   | beans::PropertyAttribute::MAYBEDEFAULT ));
  86     rOutProperties.push_back(
  87         Property( C2U( "DefaultOffset" ),
  88                   PROP_PIE_TEMPLATE_DEFAULT_OFFSET,
  89                   ::getCppuType( reinterpret_cast< const double * >(0)),
  90                   beans::PropertyAttribute::BOUND
  91                   | beans::PropertyAttribute::MAYBEDEFAULT ));
  92     rOutProperties.push_back(
  93         Property( C2U( "Dimension" ),
  94                   PROP_PIE_TEMPLATE_DIMENSION,
  95                   ::getCppuType( reinterpret_cast< const sal_Int32 * >(0)),
  96                   beans::PropertyAttribute::BOUND
  97                   | beans::PropertyAttribute::MAYBEDEFAULT ));
  98     rOutProperties.push_back(
  99         Property( C2U( "UseRings" ),
 100                   PROP_PIE_TEMPLATE_USE_RINGS,
 101                   ::getBooleanCppuType(),
 102                   beans::PropertyAttribute::BOUND
 103                   | beans::PropertyAttribute::MAYBEDEFAULT ));
 104 }
 105
 106 void lcl_AddDefaultsToMap(
 107     ::chart::tPropertyValueMap & rOutMap )
 108 {
 109     ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_PIE_TEMPLATE_OFFSET_MODE, chart2::PieChartOffsetMode_NONE );
 110     ::chart::PropertyHelper::setPropertyValueDefault< double >( rOutMap, PROP_PIE_TEMPLATE_DEFAULT_OFFSET, 0.5 );
 111     ::chart::PropertyHelper::setPropertyValueDefault< sal_Int32 >( rOutMap, PROP_PIE_TEMPLATE_DIMENSION, 2 );
 112     ::chart::PropertyHelper::setPropertyValueDefault( rOutMap, PROP_PIE_TEMPLATE_USE_RINGS, false );
 113 }
 114
 115 const uno::Sequence< Property > & lcl_GetPropertySequence()
 116 {
 117     static uno::Sequence< Property > aPropSeq;
 118
 119     // /--
 120     MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 121     if( 0 == aPropSeq.getLength() )
 122     {
 123         // get properties
 124         ::std::vector< ::com::sun::star::beans::Property > aProperties;
 125         lcl_AddPropertiesToVector( aProperties );
 126
 127         // and sort them for access via bsearch
 128         ::std::sort( aProperties.begin(), aProperties.end(),
 129                      ::chart::PropertyNameLess() );
 130
 131         // transfer result to static Sequence
 132         aPropSeq = ::chart::ContainerHelper::ContainerToSequence( aProperties );
 133     }
 134
 135     return aPropSeq;
 136 }
 137
 138 ::cppu::IPropertyArrayHelper & lcl_getInfoHelper()
 139 {
 140     static ::cppu::OPropertyArrayHelper aArrayHelper(
 141         lcl_GetPropertySequence(),
 142         /* bSorted = */ sal_True );
 143
 144     return aArrayHelper;
 145 }
 146
 147 } // anonymous namespace
 148
 149 namespace chart
 150 {
 151
 152 PieChartTypeTemplate::PieChartTypeTemplate(
 153     uno::Reference<
 154         uno::XComponentContext > const & xContext,
 155     const ::rtl::OUString & rServiceName,
 156     chart2::PieChartOffsetMode eMode,
 157     bool bRings            /* = false */,
 158     sal_Int32 nDim         /* = 2 */    ) :
 159         ChartTypeTemplate( xContext, rServiceName ),
 160         ::property::OPropertySet( m_aMutex )
 161 {
 162     setFastPropertyValue_NoBroadcast( PROP_PIE_TEMPLATE_OFFSET_MODE,    uno::makeAny( eMode ));
 163     setFastPropertyValue_NoBroadcast( PROP_PIE_TEMPLATE_DIMENSION,      uno::makeAny( nDim ));
 164     setFastPropertyValue_NoBroadcast( PROP_PIE_TEMPLATE_USE_RINGS,      uno::makeAny( sal_Bool( bRings )));
 165 }
 166
 167 PieChartTypeTemplate::~PieChartTypeTemplate()
 168 {}
 169
 170 // ____ OPropertySet ____
 171 uno::Any PieChartTypeTemplate::GetDefaultValue( sal_Int32 nHandle ) const
 172     throw(beans::UnknownPropertyException)
 173 {
 174     static tPropertyValueMap aStaticDefaults;
 175
 176     // /--
 177     ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 178     if( 0 == aStaticDefaults.size() )
 179     {
 180         // initialize defaults
 181         lcl_AddDefaultsToMap( aStaticDefaults );
 182     }
 183
 184     tPropertyValueMap::const_iterator aFound(
 185         aStaticDefaults.find( nHandle ));
 186
 187     if( aFound == aStaticDefaults.end())
 188         return uno::Any();
 189
 190     return (*aFound).second;
 191     // \--
 192 }
 193
 194 ::cppu::IPropertyArrayHelper & SAL_CALL PieChartTypeTemplate::getInfoHelper()
 195 {
 196     return lcl_getInfoHelper();
 197 }
 198
 199
 200 // ____ XPropertySet ____
 201 uno::Reference< beans::XPropertySetInfo > SAL_CALL
 202     PieChartTypeTemplate::getPropertySetInfo()
 203     throw (uno::RuntimeException)
 204 {
 205     static uno::Reference< beans::XPropertySetInfo > xInfo;
 206
 207     // /--
 208     MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 209     if( !xInfo.is())
 210     {
 211         xInfo = ::cppu::OPropertySetHelper::createPropertySetInfo(
 212             getInfoHelper());
 213     }
 214
 215     return xInfo;
 216     // \--
 217 }
 218
 219
 220 // ____ ChartTypeTemplate ____
 221 sal_Int32 PieChartTypeTemplate::getDimension() const
 222 {
 223     sal_Int32 nDim = 2;
 224     try
 225     {
 226         // note: UNO-methods are never const
 227         const_cast< PieChartTypeTemplate * >( this )->
 228             getFastPropertyValue( PROP_PIE_TEMPLATE_DIMENSION ) >>= nDim;
 229     }
 230     catch( beans::UnknownPropertyException & ex )
 231     {
 232         ASSERT_EXCEPTION( ex );
 233     }
 234
 235     return nDim;
 236 }
 237
 238 sal_Int32 PieChartTypeTemplate::getAxisCountByDimension( sal_Int32 /*nDimension*/ )
 239 {
 240     return 0;
 241 }
 242
 243 // void PieChartTypeTemplate::createAxes(
 244 //     const Sequence< Reference< chart2::XCoordinateSystem > > & rCoordSys )
 245 // {
 246 // }
 247
 248 void PieChartTypeTemplate::adaptAxes(
 249     const uno::Sequence< uno::Reference< chart2::XCoordinateSystem > > & /*rCoordSys*/ )
 250 {
 251     // hide existing axes
 252     //hhhh todo
 253 }
 254
 255 void PieChartTypeTemplate::adaptScales(
 256     const Sequence< Reference< chart2::XCoordinateSystem > > & aCooSysSeq,
 257     const Reference< chart2::data::XLabeledDataSequence > & xCategories //@todo: in future there may be more than one sequence of categories (e.g. charttype with categories at x and y axis )
 258     )
 259 {
 260     ChartTypeTemplate::adaptScales( aCooSysSeq, xCategories );
 261
 262     //remove explicit scalings from radius axis
 263     //and ensure correct orientation of scales for donuts
 264
 265     for( sal_Int32 nCooSysIdx=0; nCooSysIdx<aCooSysSeq.getLength(); ++nCooSysIdx )
 266     {
 267         try
 268         {
 269             Reference< chart2::XAxis > xAxis( AxisHelper::getAxis( 1 /*nDimensionIndex*/,0 /*nAxisIndex*/
 270                     , aCooSysSeq[nCooSysIdx] ) );
 271             if( xAxis.is() )
 272             {
 273                 chart2::ScaleData aScaleData( xAxis->getScaleData() );
 274                 AxisHelper::removeExplicitScaling( aScaleData );
 275                 aScaleData.Orientation = chart2::AxisOrientation_MATHEMATICAL;
 276                 xAxis->setScaleData( aScaleData );
 277             }
 278
 279             //------
 280
 281             xAxis = AxisHelper::getAxis( 0 /*nDimensionIndex*/,0 /*nAxisIndex*/
 282                     , aCooSysSeq[nCooSysIdx] );
 283             if( xAxis.is() )
 284             {
 285                 chart2::ScaleData aScaleData( xAxis->getScaleData() );
 286                 aScaleData.Orientation = chart2::AxisOrientation_REVERSE;
 287                 xAxis->setScaleData( aScaleData );
 288             }
 289         }
 290         catch( const uno::Exception & ex )
 291         {
 292             ASSERT_EXCEPTION( ex );
 293         }
 294     }
 295 }
 296
 297 void PieChartTypeTemplate::createChartTypes(
 298     const Sequence< Sequence< Reference< chart2::XDataSeries > > > & aSeriesSeq,
 299     const Sequence< Reference< chart2::XCoordinateSystem > > & rCoordSys,
 300     const Sequence< Reference< chart2::XChartType > >& /* aOldChartTypesSeq */ )
 301 {
 302     if( rCoordSys.getLength() == 0 ||
 303         ! rCoordSys[0].is() )
 304         return;
 305
 306     try
 307     {
 308         Reference< lang::XMultiServiceFactory > xFact(
 309             GetComponentContext()->getServiceManager(), uno::UNO_QUERY_THROW );
 310
 311         Reference< chart2::XChartType > xCT(
 312             xFact->createInstance( CHART2_SERVICE_NAME_CHARTTYPE_PIE ), uno::UNO_QUERY_THROW );
 313         Reference< beans::XPropertySet > xCTProp( xCT, uno::UNO_QUERY );
 314         if( xCTProp.is())
 315         {
 316             xCTProp->setPropertyValue(
 317                 C2U( "UseRings" ), getFastPropertyValue( PROP_PIE_TEMPLATE_USE_RINGS ));
 318         }
 319         Reference< chart2::XChartTypeContainer > xCTCnt( rCoordSys[0], uno::UNO_QUERY_THROW );
 320         xCTCnt->setChartTypes( Sequence< Reference< chart2::XChartType > >( &xCT, 1 ));
 321
 322         if( aSeriesSeq.getLength() > 0 )
 323         {
 324             Reference< chart2::XDataSeriesContainer > xDSCnt( xCT, uno::UNO_QUERY_THROW );
 325             Sequence< Reference< chart2::XDataSeries > > aFlatSeriesSeq( FlattenSequence( aSeriesSeq ));
 326             xDSCnt->setDataSeries( aFlatSeriesSeq );
 327
 328             DataSeriesHelper::setStackModeAtSeries(
 329                 aFlatSeriesSeq, rCoordSys[0], getStackMode( 0 ));
 330         }
 331     }
 332     catch( uno::Exception & ex )
 333     {
 334         ASSERT_EXCEPTION( ex );
 335     }
 336 }
 337
 338 // ____ XChartTypeTemplate ____
 339 sal_Bool SAL_CALL PieChartTypeTemplate::matchesTemplate(
 340     const uno::Reference< chart2::XDiagram >& xDiagram,
 341     sal_Bool bAdaptProperties )
 342     throw (uno::RuntimeException)
 343 {
 344     sal_Bool bResult = ChartTypeTemplate::matchesTemplate( xDiagram, bAdaptProperties );
 345
 346     sal_Bool bTemplateUsesRings = sal_False;
 347     getFastPropertyValue( PROP_PIE_TEMPLATE_USE_RINGS ) >>= bTemplateUsesRings;
 348     chart2::PieChartOffsetMode ePieOffsetMode;
 349     getFastPropertyValue( PROP_PIE_TEMPLATE_OFFSET_MODE ) >>= ePieOffsetMode;
 350
 351     //check offset-mode
 352     if( bResult )
 353     {
 354         try
 355         {
 356             double fOffset=0.0;
 357             bool bAllOffsetsEqual = true;
 358
 359             ::std::vector< Reference< chart2::XDataSeries > > aSeriesVec(
 360                 DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
 361
 362             //check offset of outer series
 363             if( aSeriesVec.size() )
 364             {
 365                 sal_Int32 nOuterSeriesIndex = 0; //@todo in future this will depend on Orientation of the radius axis scale
 366                 Reference< chart2::XDataSeries > xSeries( aSeriesVec[nOuterSeriesIndex] );
 367                 Reference< beans::XPropertySet > xProp( xSeries, uno::UNO_QUERY_THROW );
 368                 xProp->getPropertyValue( C2U( "Offset" )) >>= fOffset;
 369
 370                 //get AttributedDataPoints
 371                 uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 372                 if( xProp->getPropertyValue( C2U( "AttributedDataPoints" ) ) >>= aAttributedDataPointIndexList )
 373                 {
 374                     for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
 375                     {
 376                         uno::Reference< beans::XPropertySet > xPointProp( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]) );
 377                         if(xPointProp.is())
 378                         {
 379                             double fPointOffset=0.0;
 380                             if( (xProp->getPropertyValue( C2U( "Offset" )) >>= fPointOffset ) )
 381                             {
 382                                 if( ! ::rtl::math::approxEqual( fPointOffset, fOffset ) )
 383                                 {
 384                                     bAllOffsetsEqual = false;
 385                                     break;
 386                                 }
 387                             }
 388                         }
 389                     }
 390                 }
 391             }
 392
 393             chart2::PieChartOffsetMode eOffsetMode = chart2::PieChartOffsetMode_NONE;
 394             if( bAllOffsetsEqual && fOffset > 0.0 )
 395             {
 396                 eOffsetMode = chart2::PieChartOffsetMode_ALL_EXPLODED;
 397                 if( bAdaptProperties )
 398                     setFastPropertyValue_NoBroadcast( PROP_PIE_TEMPLATE_DEFAULT_OFFSET, uno::makeAny( fOffset ));
 399             }
 400
 401             bResult = ( eOffsetMode == ePieOffsetMode );
 402         }
 403         catch( uno::Exception & ex )
 404         {
 405             ASSERT_EXCEPTION( ex );
 406             bResult = false;
 407         }
 408     }
 409
 410     //check UseRings
 411     if( bResult )
 412     {
 413         uno::Reference< beans::XPropertySet > xCTProp(
 414             DiagramHelper::getChartTypeByIndex( xDiagram, 0 ), uno::UNO_QUERY_THROW );
 415         sal_Bool bUseRings = false;
 416         if( xCTProp->getPropertyValue( C2U( "UseRings" )) >>= bUseRings )
 417         {
 418             bResult = ( bTemplateUsesRings == bUseRings );
 419         }
 420     }
 421
 422     return bResult;
 423 }
 424
 425 Reference< chart2::XChartType > PieChartTypeTemplate::getChartTypeForIndex( sal_Int32 /*nChartTypeIndex*/ )
 426 {
 427     Reference< chart2::XChartType > xResult;
 428
 429     try
 430     {
 431         Reference< lang::XMultiServiceFactory > xFact(
 432             GetComponentContext()->getServiceManager(), uno::UNO_QUERY_THROW );
 433         xResult.set( xFact->createInstance(
 434                          CHART2_SERVICE_NAME_CHARTTYPE_PIE ), uno::UNO_QUERY_THROW );
 435         Reference< beans::XPropertySet > xCTProp( xResult, uno::UNO_QUERY );
 436         if( xCTProp.is())
 437         {
 438             xCTProp->setPropertyValue(
 439                 C2U( "UseRings" ), getFastPropertyValue( PROP_PIE_TEMPLATE_USE_RINGS ));
 440         }
 441
 442     }
 443     catch( uno::Exception & ex )
 444     {
 445         ASSERT_EXCEPTION( ex );
 446     }
 447
 448     return xResult;
 449 }
 450
 451 Reference< chart2::XChartType > SAL_CALL PieChartTypeTemplate::getChartTypeForNewSeries(
 452         const uno::Sequence< Reference< chart2::XChartType > >& aFormerlyUsedChartTypes )
 453     throw (uno::RuntimeException)
 454 {
 455     Reference< chart2::XChartType > xResult;
 456
 457     try
 458     {
 459         Reference< lang::XMultiServiceFactory > xFact(
 460             GetComponentContext()->getServiceManager(), uno::UNO_QUERY_THROW );
 461         xResult.set( xFact->createInstance(
 462                          CHART2_SERVICE_NAME_CHARTTYPE_PIE ), uno::UNO_QUERY_THROW );
 463         ChartTypeTemplate::copyPropertiesFromOldToNewCoordianteSystem( aFormerlyUsedChartTypes, xResult );
 464         Reference< beans::XPropertySet > xCTProp( xResult, uno::UNO_QUERY );
 465         if( xCTProp.is())
 466         {
 467             xCTProp->setPropertyValue(
 468                 C2U( "UseRings" ), getFastPropertyValue( PROP_PIE_TEMPLATE_USE_RINGS ));
 469         }
 470
 471     }
 472     catch( uno::Exception & ex )
 473     {
 474         ASSERT_EXCEPTION( ex );
 475     }
 476
 477     setStackModePropertiesToChartType(xResult);
 478     return xResult;
 479 }
 480
 481 void SAL_CALL PieChartTypeTemplate::applyStyle(
 482     const Reference< chart2::XDataSeries >& xSeries,
 483     ::sal_Int32 nChartTypeIndex,
 484     ::sal_Int32 nSeriesIndex,
 485     ::sal_Int32 nSeriesCount )
 486     throw (uno::RuntimeException)
 487 {
 488     ChartTypeTemplate::applyStyle( xSeries, nChartTypeIndex, nSeriesIndex, nSeriesCount );
 489
 490     try
 491     {
 492         uno::Reference< beans::XPropertySet > xProp( xSeries, uno::UNO_QUERY_THROW );
 493
 494         sal_Bool bTemplateUsesRings = sal_False;
 495         getFastPropertyValue( PROP_PIE_TEMPLATE_USE_RINGS ) >>= bTemplateUsesRings;
 496         sal_Int32 nOuterSeriesIndex = 0; //@todo in future this will depend on Orientation of the radius axis scale
 497         if( nSeriesIndex == nOuterSeriesIndex )
 498         {
 499             const OUString aOffsetPropName( RTL_CONSTASCII_USTRINGPARAM("Offset"));
 500             // get offset mode
 501             chart2::PieChartOffsetMode ePieOffsetMode;
 502             this->getFastPropertyValue( PROP_PIE_TEMPLATE_OFFSET_MODE ) >>= ePieOffsetMode;
 503
 504             // get default offset
 505             double fDefaultOffset = 0.5;
 506             this->getFastPropertyValue( PROP_PIE_TEMPLATE_DEFAULT_OFFSET ) >>= fDefaultOffset;
 507             double fOffsetToSet = fDefaultOffset;
 508
 509             uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 510             xProp->getPropertyValue( C2U( "AttributedDataPoints" ) ) >>= aAttributedDataPointIndexList;
 511
 512             // determine whether to set the new offset
 513             bool bSetOffset = ( ePieOffsetMode == chart2::PieChartOffsetMode_ALL_EXPLODED );
 514             if( !bSetOffset &&
 515                 (ePieOffsetMode == chart2::PieChartOffsetMode_NONE) )
 516             {
 517                 // set offset to 0 if the offset was exactly "all exploded"
 518                 // before (individual offsets are kept)
 519                 double fOffset = 0.0;
 520                 if( (xProp->getPropertyValue( aOffsetPropName ) >>= fOffset) &&
 521                     ::rtl::math::approxEqual( fOffset, fDefaultOffset ))
 522                 {
 523                     fOffsetToSet = 0.0;
 524                     bSetOffset = true;
 525                     for( sal_Int32 nPtIdx=0; nPtIdx<aAttributedDataPointIndexList.getLength(); ++nPtIdx )
 526                     {
 527                         uno::Reference< beans::XPropertySet > xPointProp(
 528                             xSeries->getDataPointByIndex( aAttributedDataPointIndexList[ nPtIdx ] ));
 529                         uno::Reference< beans::XPropertyState > xPointState( xPointProp, uno::UNO_QUERY );
 530                         double fPointOffset = 0.0;
 531                         if( xPointState.is() &&
 532                             (xPointState->getPropertyState( aOffsetPropName ) == beans::PropertyState_DIRECT_VALUE) &&
 533                             xPointProp.is() &&
 534                             (xPointProp->getPropertyValue( aOffsetPropName ) >>= fPointOffset ) &&
 535                             ! ::rtl::math::approxEqual( fPointOffset, fDefaultOffset ) )
 536                         {
 537                             bSetOffset = false;
 538                             break;
 539                         }
 540                     }
 541                 }
 542             }
 543
 544             if( bSetOffset )
 545             {
 546                 // set the offset to the series and to the attributed data points
 547                 xProp->setPropertyValue( aOffsetPropName, uno::makeAny( fOffsetToSet ));
 548
 549                 // remove hard attributes from data points
 550                 for( sal_Int32 nPtIdx=0; nPtIdx<aAttributedDataPointIndexList.getLength(); ++nPtIdx )
 551                 {
 552                     uno::Reference< beans::XPropertyState > xPointState(
 553                         xSeries->getDataPointByIndex( aAttributedDataPointIndexList[ nPtIdx ] ), uno::UNO_QUERY );
 554                     if( xPointState.is())
 555                         xPointState->setPropertyToDefault( aOffsetPropName );
 556                 }
 557             }
 558         }
 559
 560         // line style
 561         drawing::LineStyle eStyle = (getDimension() == 2)
 562             ? drawing::LineStyle_SOLID
 563             : drawing::LineStyle_NONE;
 564
 565         xProp->setPropertyValue( C2U("BorderStyle"),
 566                                  uno::makeAny( eStyle ));
 567
 568         // vary colors by point
 569         xProp->setPropertyValue( C2U("VaryColorsByPoint"), uno::makeAny( true ));
 570     }
 571     catch( uno::Exception & ex )
 572     {
 573         ASSERT_EXCEPTION( ex );
 574     }
 575 }
 576
 577
 578 void SAL_CALL PieChartTypeTemplate::resetStyles( const Reference< chart2::XDiagram >& xDiagram )
 579     throw (uno::RuntimeException)
 580 {
 581     // reset axes and grids
 582     Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY );
 583     if( xCooSysCnt.is())
 584     {
 585         Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems());
 586         ChartTypeTemplate::createAxes( aCooSysSeq );
 587
 588         //reset scale orientation
 589         for( sal_Int32 nCooSysIdx=0; nCooSysIdx<aCooSysSeq.getLength(); ++nCooSysIdx )
 590         {
 591             try
 592             {
 593                 Reference< chart2::XAxis > xAxis( AxisHelper::getAxis( 0 /*nDimensionIndex*/,0 /*nAxisIndex*/
 594                         , aCooSysSeq[nCooSysIdx] ) );
 595                 if( xAxis.is() )
 596                 {
 597                     chart2::ScaleData aScaleData( xAxis->getScaleData() );
 598                     aScaleData.Orientation = chart2::AxisOrientation_MATHEMATICAL;
 599                     xAxis->setScaleData( aScaleData );
 600                 }
 601
 602                 xAxis = AxisHelper::getAxis( 1, 0, aCooSysSeq[nCooSysIdx] );
 603                 if( xAxis.is() )
 604                 {
 605                     chart2::ScaleData aScaleData( xAxis->getScaleData() );
 606                     aScaleData.Orientation = chart2::AxisOrientation_MATHEMATICAL;
 607                     xAxis->setScaleData( aScaleData );
 608                 }
 609             }
 610             catch( const uno::Exception & ex )
 611             {
 612                 ASSERT_EXCEPTION( ex );
 613             }
 614         }
 615     }
 616
 617     ChartTypeTemplate::resetStyles( xDiagram );
 618
 619     // vary colors by point,
 620     // line style
 621     ::std::vector< Reference< chart2::XDataSeries > > aSeriesVec(
 622         DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
 623     drawing::LineStyle eStyle = (getDimension() == 2)
 624         ? drawing::LineStyle_SOLID
 625         : drawing::LineStyle_NONE;
 626     uno::Any aLineStyleAny( uno::makeAny( eStyle ));
 627     for( ::std::vector< Reference< chart2::XDataSeries > >::iterator aIt( aSeriesVec.begin());
 628          aIt != aSeriesVec.end(); ++aIt )
 629     {
 630         Reference< beans::XPropertyState > xState( *aIt, uno::UNO_QUERY );
 631         if( xState.is())
 632         {
 633             xState->setPropertyToDefault( C2U("VaryColorsByPoint"));
 634             Reference< beans::XPropertySet > xProp( xState, uno::UNO_QUERY );
 635             if( xProp.is() &&
 636                 xProp->getPropertyValue( C2U("BorderStyle")) == aLineStyleAny )
 637             {
 638                 xState->setPropertyToDefault( C2U("BorderStyle"));
 639             }
 640         }
 641     }
 642
 643     //reset scene properties
 644     ThreeDHelper::setDefaultRotation( uno::Reference< beans::XPropertySet >( xDiagram, uno::UNO_QUERY ), false );
 645 }
 646
 647 // ____ XChartTypeTemplate ____
 648 void PieChartTypeTemplate::adaptDiagram( const uno::Reference< chart2::XDiagram >& xDiagram )
 649 {
 650     if( !xDiagram.is() )
 651         return;
 652
 653     //different default for scene geometry:
 654     ThreeDHelper::setDefaultRotation( uno::Reference< beans::XPropertySet >( xDiagram, uno::UNO_QUERY ), true );
 655 }
 656
 657 // ----------------------------------------
 658
 659 uno::Sequence< ::rtl::OUString > PieChartTypeTemplate::getSupportedServiceNames_Static()
 660 {
 661     uno::Sequence< ::rtl::OUString > aServices( 2 );
 662     aServices[ 0 ] = lcl_aServiceName;
 663     aServices[ 1 ] = C2U( "com.sun.star.chart2.ChartTypeTemplate" );
 664     return aServices;
 665 }
 666
 667 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 668 APPHELPER_XSERVICEINFO_IMPL( PieChartTypeTemplate, lcl_aServiceName );
 669
 670 IMPLEMENT_FORWARD_XINTERFACE2( PieChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 671 IMPLEMENT_FORWARD_XTYPEPROVIDER2( PieChartTypeTemplate, ChartTypeTemplate, OPropertySet )
 672
 673 } //  namespace chart