chart2/source/view/axes/VCoordinateSystem.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 <BaseGFXHelper.hxx>
  21 #include <VCoordinateSystem.hxx>
  22 #include "VCartesianCoordinateSystem.hxx"
  23 #include "VPolarCoordinateSystem.hxx"
  24 #include <ScaleAutomatism.hxx>
  25 #include <ShapeFactory.hxx>
  26 #include <servicenames_coosystems.hxx>
  27 #include <ObjectIdentifier.hxx>
  28 #include <ExplicitCategoriesProvider.hxx>
  29 #include "VAxisBase.hxx"
  30 #include <defines.hxx>
  31 #include <chartview/ExplicitValueProvider.hxx>
  32 #include <com/sun/star/chart/TimeUnit.hpp>
  33 #include <com/sun/star/chart2/AxisType.hpp>
  34 #include <com/sun/star/chart2/XCoordinateSystem.hpp>
  35 #include <comphelper/sequence.hxx>
  36 #include <tools/diagnose_ex.h>
  37 #include <algorithm>
  38 #include <rtl/math.hxx>
  39
  40 namespace chart
  41 {
  42 using namespace ::com::sun::star;
  43 using namespace ::com::sun::star::chart2;
  44 using ::com::sun::star::uno::Reference;
  45 using ::com::sun::star::uno::Sequence;
  46
  47 std::unique_ptr<VCoordinateSystem> VCoordinateSystem::createCoordinateSystem(
  48             const Reference< XCoordinateSystem >& xCooSysModel )
  49 {
  50     if( !xCooSysModel.is() )
  51         return nullptr;
  52
  53     OUString aViewServiceName = xCooSysModel->getViewServiceName();
  54
  55     //@todo: in future the coordinatesystems should be instantiated via service factory
  56     std::unique_ptr<VCoordinateSystem> pRet;
  57     if( aViewServiceName == CHART2_COOSYSTEM_CARTESIAN_VIEW_SERVICE_NAME )
  58         pRet.reset( new VCartesianCoordinateSystem(xCooSysModel) );
  59     else if( aViewServiceName == CHART2_COOSYSTEM_POLAR_VIEW_SERVICE_NAME )
  60         pRet.reset( new VPolarCoordinateSystem(xCooSysModel) );
  61     if(!pRet)
  62         pRet.reset( new VCoordinateSystem(xCooSysModel) );
  63     return pRet;
  64 }
  65
  66 VCoordinateSystem::VCoordinateSystem( const Reference< XCoordinateSystem >& xCooSys )
  67     : m_xCooSysModel(xCooSys)
  68     , m_aMatrixSceneToScreen()
  69     , m_eLeftWallPos(CuboidPlanePosition_Left)
  70     , m_eBackWallPos(CuboidPlanePosition_Back)
  71     , m_eBottomPos(CuboidPlanePosition_Bottom)
  72     , m_aMergedMinMaxSupplier()
  73     , m_aExplicitScales(3)
  74     , m_aExplicitIncrements(3)
  75 {
  76     if( !m_xCooSysModel.is() || m_xCooSysModel->getDimension()<3 )
  77     {
  78         m_aExplicitScales[2].Minimum = 1.0;
  79         m_aExplicitScales[2].Maximum = 2.0;
  80         m_aExplicitScales[2].Orientation = AxisOrientation_MATHEMATICAL;
  81     }
  82 }
  83 VCoordinateSystem::~VCoordinateSystem()
  84 {
  85 }
  86
  87 void VCoordinateSystem::initPlottingTargets(  const Reference< drawing::XShapes >& xLogicTarget
  88        , const Reference< drawing::XShapes >& xFinalTarget
  89        , const Reference< lang::XMultiServiceFactory >& xShapeFactory
  90        , Reference< drawing::XShapes >& xLogicTargetForSeriesBehindAxis )
  91 {
  92     OSL_PRECOND(xLogicTarget.is()&&xFinalTarget.is()&&xShapeFactory.is(),"no proper initialization parameters");
  93     //is only allowed to be called once
  94
  95     sal_Int32 nDimensionCount = m_xCooSysModel->getDimension();
  96     //create group shape for grids first thus axes are always painted above grids
  97     ShapeFactory* pShapeFactory = ShapeFactory::getOrCreateShapeFactory(xShapeFactory);
  98     if(nDimensionCount==2)
  99     {
 100         //create and add to target
 101         m_xLogicTargetForGrids = pShapeFactory->createGroup2D( xLogicTarget );
 102         xLogicTargetForSeriesBehindAxis = pShapeFactory->createGroup2D( xLogicTarget );
 103         m_xLogicTargetForAxes = pShapeFactory->createGroup2D( xLogicTarget );
 104     }
 105     else
 106     {
 107         //create and added to target
 108         m_xLogicTargetForGrids = pShapeFactory->createGroup3D( xLogicTarget );
 109         xLogicTargetForSeriesBehindAxis = pShapeFactory->createGroup3D( xLogicTarget );
 110         m_xLogicTargetForAxes = pShapeFactory->createGroup3D( xLogicTarget );
 111     }
 112     m_xFinalTarget  = xFinalTarget;
 113     m_xShapeFactory = xShapeFactory;
 114 }
 115
 116 void VCoordinateSystem::setParticle( const OUString& rCooSysParticle )
 117 {
 118     m_aCooSysParticle = rCooSysParticle;
 119 }
 120
 121 void VCoordinateSystem::setTransformationSceneToScreen(
 122     const drawing::HomogenMatrix& rMatrix )
 123 {
 124     m_aMatrixSceneToScreen = rMatrix;
 125
 126     //correct transformation for axis
 127     for (auto const& elem : m_aAxisMap)
 128     {
 129         VAxisBase* pVAxis = elem.second.get();
 130         if( pVAxis )
 131         {
 132             if(pVAxis->getDimensionCount()==2)
 133                 pVAxis->setTransformationSceneToScreen( m_aMatrixSceneToScreen );
 134         }
 135     }
 136 }
 137
 138 //better performance for big data
 139 uno::Sequence< sal_Int32 > VCoordinateSystem::getCoordinateSystemResolution(
 140             const awt::Size& rPageSize, const awt::Size& rPageResolution )
 141 {
 142     uno::Sequence<sal_Int32> aResolution(
 143         std::max<sal_Int32>(m_xCooSysModel->getDimension(), 2));
 144
 145     for( auto& i : aResolution )
 146         i = 1000;
 147
 148     ::basegfx::B3DTuple aScale( BaseGFXHelper::GetScaleFromMatrix(
 149         BaseGFXHelper::HomogenMatrixToB3DHomMatrix(
 150             m_aMatrixSceneToScreen ) ) );
 151
 152     double fCoosysWidth = fabs(aScale.getX()*FIXED_SIZE_FOR_3D_CHART_VOLUME);
 153     double fCoosysHeight = fabs(aScale.getY()*FIXED_SIZE_FOR_3D_CHART_VOLUME);
 154
 155     double fPageWidth = rPageSize.Width;
 156     double fPageHeight = rPageSize.Height;
 157
 158     //factor 2 to avoid rounding problems
 159     sal_Int32 nXResolution = static_cast<sal_Int32>(2.0*static_cast<double>(rPageResolution.Width)*fCoosysWidth/fPageWidth);
 160     sal_Int32 nYResolution = static_cast<sal_Int32>(2.0*static_cast<double>(rPageResolution.Height)*fCoosysHeight/fPageHeight);
 161
 162     if( nXResolution < 10 )
 163         nXResolution = 10;
 164     if( nYResolution < 10 )
 165         nYResolution = 10;
 166
 167     if( getPropertySwapXAndYAxis() )
 168         std::swap(nXResolution,nYResolution);
 169
 170     //2D
 171     if( aResolution.getLength() == 2 )
 172     {
 173         aResolution[0]=nXResolution;
 174         aResolution[1]=nYResolution;
 175     }
 176     else
 177     {
 178         //this maybe can be optimized further ...
 179         sal_Int32 nMaxResolution = std::max( nXResolution, nYResolution );
 180         nMaxResolution*=2;
 181         for( auto& i : aResolution )
 182             i = nMaxResolution;
 183     }
 184
 185     return aResolution;
 186 }
 187
 188 Reference< XAxis > VCoordinateSystem::getAxisByDimension( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const
 189 {
 190     if( m_xCooSysModel.is() )
 191         return m_xCooSysModel->getAxisByDimension( nDimensionIndex, nAxisIndex );
 192     return nullptr;
 193 }
 194
 195 Sequence< Reference< beans::XPropertySet > > VCoordinateSystem::getGridListFromAxis( const Reference< XAxis >& xAxis )
 196 {
 197     std::vector< Reference< beans::XPropertySet > > aRet;
 198
 199     if( xAxis.is() )
 200     {
 201         aRet.push_back( xAxis->getGridProperties() );
 202         auto aSubGrids( comphelper::sequenceToContainer<std::vector< Reference< beans::XPropertySet > > >( xAxis->getSubGridProperties() ) );
 203         aRet.insert( aRet.end(), aSubGrids.begin(), aSubGrids.end() );
 204     }
 205
 206     return comphelper::containerToSequence( aRet );
 207 }
 208
 209 void VCoordinateSystem::impl_adjustDimension( sal_Int32& rDimensionIndex )
 210 {
 211     if( rDimensionIndex<0 )
 212         rDimensionIndex=0;
 213     if( rDimensionIndex>2 )
 214         rDimensionIndex=2;
 215 }
 216
 217 void VCoordinateSystem::impl_adjustDimensionAndIndex( sal_Int32& rDimensionIndex, sal_Int32& rAxisIndex ) const
 218 {
 219     impl_adjustDimension( rDimensionIndex );
 220
 221     if( rAxisIndex < 0 || rAxisIndex > getMaximumAxisIndexByDimension(rDimensionIndex) )
 222         rAxisIndex = 0;
 223 }
 224
 225 void VCoordinateSystem::setExplicitCategoriesProvider( ExplicitCategoriesProvider* pExplicitCategoriesProvider /*takes ownership*/ )
 226 {
 227     m_apExplicitCategoriesProvider.reset(pExplicitCategoriesProvider);
 228 }
 229
 230 ExplicitCategoriesProvider* VCoordinateSystem::getExplicitCategoriesProvider()
 231 {
 232     return m_apExplicitCategoriesProvider.get();
 233 }
 234
 235 std::vector< ExplicitScaleData > VCoordinateSystem::getExplicitScales( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const
 236 {
 237     std::vector< ExplicitScaleData > aRet(m_aExplicitScales);
 238
 239     impl_adjustDimensionAndIndex( nDimensionIndex, nAxisIndex );
 240     aRet[nDimensionIndex]=getExplicitScale( nDimensionIndex, nAxisIndex );
 241
 242     return aRet;
 243 }
 244
 245 std::vector< ExplicitIncrementData > VCoordinateSystem::getExplicitIncrements( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const
 246 {
 247     std::vector< ExplicitIncrementData > aRet(m_aExplicitIncrements);
 248
 249     impl_adjustDimensionAndIndex( nDimensionIndex, nAxisIndex );
 250     aRet[nDimensionIndex]=getExplicitIncrement( nDimensionIndex, nAxisIndex );
 251
 252     return aRet;
 253 }
 254
 255 ExplicitScaleData VCoordinateSystem::getExplicitScale( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const
 256 {
 257     ExplicitScaleData aRet;
 258
 259     impl_adjustDimensionAndIndex( nDimensionIndex, nAxisIndex );
 260
 261     if( nAxisIndex == 0)
 262     {
 263         aRet = m_aExplicitScales[nDimensionIndex];
 264     }
 265     else
 266     {
 267         tFullAxisIndex aFullAxisIndex( nDimensionIndex, nAxisIndex );
 268         tFullExplicitScaleMap::const_iterator aIt = m_aSecondaryExplicitScales.find( aFullAxisIndex );
 269         if( aIt != m_aSecondaryExplicitScales.end() )
 270             aRet = aIt->second;
 271         else
 272             aRet = m_aExplicitScales[nDimensionIndex];
 273     }
 274
 275     return aRet;
 276 }
 277
 278 ExplicitIncrementData VCoordinateSystem::getExplicitIncrement( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const
 279 {
 280     ExplicitIncrementData aRet;
 281
 282     impl_adjustDimensionAndIndex( nDimensionIndex, nAxisIndex );
 283
 284     if( nAxisIndex == 0)
 285     {
 286         aRet = m_aExplicitIncrements[nDimensionIndex];
 287     }
 288     else
 289     {
 290         tFullAxisIndex aFullAxisIndex( nDimensionIndex, nAxisIndex );
 291         tFullExplicitIncrementMap::const_iterator aIt = m_aSecondaryExplicitIncrements.find( aFullAxisIndex );
 292         if( aIt != m_aSecondaryExplicitIncrements.end() )
 293             aRet = aIt->second;
 294         else
 295             aRet = m_aExplicitIncrements[nDimensionIndex];
 296     }
 297
 298     return aRet;
 299 }
 300
 301 OUString VCoordinateSystem::createCIDForAxis( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
 302 {
 303     OUString aAxisParticle( ObjectIdentifier::createParticleForAxis( nDimensionIndex, nAxisIndex ) );
 304     return ObjectIdentifier::createClassifiedIdentifierForParticles( m_aCooSysParticle, aAxisParticle );
 305 }
 306 OUString VCoordinateSystem::createCIDForGrid( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
 307 {
 308     OUString aGridParticle( ObjectIdentifier::createParticleForGrid( nDimensionIndex, nAxisIndex ) );
 309     return ObjectIdentifier::createClassifiedIdentifierForParticles( m_aCooSysParticle, aGridParticle );
 310 }
 311
 312 sal_Int32 VCoordinateSystem::getMaximumAxisIndexByDimension( sal_Int32 nDimensionIndex ) const
 313 {
 314     sal_Int32 nRet = 0;
 315     for (auto const& elem : m_aSecondaryExplicitScales)
 316     {
 317         if(elem.first.first==nDimensionIndex)
 318         {
 319             sal_Int32 nLocalIdx = elem.first.second;
 320             if( nRet < nLocalIdx )
 321                 nRet = nLocalIdx;
 322         }
 323     }
 324     return nRet;
 325 }
 326
 327 void VCoordinateSystem::createVAxisList(
 328               const uno::Reference<chart2::XChartDocument> & /* xChartDoc */
 329             , const awt::Size& /* rFontReferenceSize */
 330             , const awt::Rectangle& /* rMaximumSpaceForLabels */
 331             , bool /* bLimitSpaceForLabels */
 332             )
 333 {
 334 }
 335
 336 void VCoordinateSystem::initVAxisInList()
 337 {
 338 }
 339 void VCoordinateSystem::updateScalesAndIncrementsOnAxes()
 340 {
 341 }
 342
 343 void VCoordinateSystem::prepareAutomaticAxisScaling( ScaleAutomatism& rScaleAutomatism, sal_Int32 nDimIndex, sal_Int32 nAxisIndex )
 344 {
 345     if( rScaleAutomatism.getScale().AxisType==AxisType::DATE && nDimIndex==0 )
 346     {
 347         // This is a date X dimension.  Determine proper time resolution.
 348         sal_Int32 nTimeResolution = css::chart::TimeUnit::MONTH;
 349         if( !(rScaleAutomatism.getScale().TimeIncrement.TimeResolution >>= nTimeResolution) )
 350         {
 351             nTimeResolution = m_aMergedMinMaxSupplier.calculateTimeResolutionOnXAxis();
 352             rScaleAutomatism.setAutomaticTimeResolution( nTimeResolution );
 353         }
 354         m_aMergedMinMaxSupplier.setTimeResolutionOnXAxis( nTimeResolution, rScaleAutomatism.getNullDate() );
 355     }
 356
 357     double fMin = 0.0;
 358     double fMax = 0.0;
 359     ::rtl::math::setInf(&fMin, false);
 360     ::rtl::math::setInf(&fMax, true);
 361     if( nDimIndex == 0 )
 362     {
 363         // x dimension
 364         fMin = m_aMergedMinMaxSupplier.getMinimumX();
 365         fMax = m_aMergedMinMaxSupplier.getMaximumX();
 366     }
 367     else if( nDimIndex == 1 )
 368     {
 369         // y dimension
 370         ExplicitScaleData aScale = getExplicitScale( 0, 0 );
 371         fMin = m_aMergedMinMaxSupplier.getMinimumYInRange(aScale.Minimum,aScale.Maximum, nAxisIndex);
 372         fMax = m_aMergedMinMaxSupplier.getMaximumYInRange(aScale.Minimum,aScale.Maximum, nAxisIndex);
 373     }
 374     else if( nDimIndex == 2 )
 375     {
 376         // z dimension
 377         fMin = m_aMergedMinMaxSupplier.getMinimumZ();
 378         fMax = m_aMergedMinMaxSupplier.getMaximumZ();
 379     }
 380
 381     //merge our values with those already contained in rScaleAutomatism
 382     rScaleAutomatism.expandValueRange( fMin, fMax );
 383
 384     rScaleAutomatism.setAutoScalingOptions(
 385         m_aMergedMinMaxSupplier.isExpandBorderToIncrementRhythm( nDimIndex ),
 386         m_aMergedMinMaxSupplier.isExpandIfValuesCloseToBorder( nDimIndex ),
 387         m_aMergedMinMaxSupplier.isExpandWideValuesToZero( nDimIndex ),
 388         m_aMergedMinMaxSupplier.isExpandNarrowValuesTowardZero( nDimIndex ) );
 389
 390     VAxisBase* pVAxis = getVAxis(nDimIndex, nAxisIndex);
 391     if( pVAxis )
 392         rScaleAutomatism.setMaximumAutoMainIncrementCount( pVAxis->estimateMaximumAutoMainIncrementCount() );
 393 }
 394
 395 VAxisBase* VCoordinateSystem::getVAxis( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
 396 {
 397     VAxisBase* pRet = nullptr;
 398
 399     tFullAxisIndex aFullAxisIndex( nDimensionIndex, nAxisIndex );
 400
 401     tVAxisMap::const_iterator aIt = m_aAxisMap.find( aFullAxisIndex );
 402     if( aIt != m_aAxisMap.end() )
 403         pRet = aIt->second.get();
 404
 405     return pRet;
 406 }
 407
 408 void VCoordinateSystem::setExplicitScaleAndIncrement(
 409           sal_Int32 nDimensionIndex
 410         , sal_Int32 nAxisIndex
 411         , const ExplicitScaleData& rExplicitScale
 412         , const ExplicitIncrementData& rExplicitIncrement )
 413 {
 414     impl_adjustDimension( nDimensionIndex );
 415
 416     if( nAxisIndex==0 )
 417     {
 418         m_aExplicitScales[nDimensionIndex]=rExplicitScale;
 419         m_aExplicitIncrements[nDimensionIndex]=rExplicitIncrement;
 420     }
 421     else
 422     {
 423         tFullAxisIndex aFullAxisIndex( nDimensionIndex, nAxisIndex );
 424         m_aSecondaryExplicitScales[aFullAxisIndex] = rExplicitScale;
 425         m_aSecondaryExplicitIncrements[aFullAxisIndex] = rExplicitIncrement;
 426     }
 427 }
 428
 429 void VCoordinateSystem::set3DWallPositions( CuboidPlanePosition eLeftWallPos, CuboidPlanePosition eBackWallPos, CuboidPlanePosition eBottomPos )
 430 {
 431     m_eLeftWallPos = eLeftWallPos;
 432     m_eBackWallPos = eBackWallPos;
 433     m_eBottomPos = eBottomPos;
 434 }
 435
 436 void VCoordinateSystem::createMaximumAxesLabels()
 437 {
 438     for (auto const& elem : m_aAxisMap)
 439     {
 440         VAxisBase* pVAxis = elem.second.get();
 441         if( pVAxis )
 442         {
 443             if(pVAxis->getDimensionCount()==2)
 444                 pVAxis->setTransformationSceneToScreen( m_aMatrixSceneToScreen );
 445             pVAxis->createMaximumLabels();
 446         }
 447     }
 448 }
 449 void VCoordinateSystem::createAxesLabels()
 450 {
 451     for (auto const& elem : m_aAxisMap)
 452     {
 453         VAxisBase* pVAxis = elem.second.get();
 454         if( pVAxis )
 455         {
 456             if(pVAxis->getDimensionCount()==2)
 457                 pVAxis->setTransformationSceneToScreen( m_aMatrixSceneToScreen );
 458             pVAxis->createLabels();
 459         }
 460     }
 461 }
 462
 463 void VCoordinateSystem::updatePositions()
 464 {
 465     for (auto const& elem : m_aAxisMap)
 466     {
 467         VAxisBase* pVAxis = elem.second.get();
 468         if( pVAxis )
 469         {
 470             if(pVAxis->getDimensionCount()==2)
 471                 pVAxis->setTransformationSceneToScreen( m_aMatrixSceneToScreen );
 472             pVAxis->updatePositions();
 473         }
 474     }
 475 }
 476
 477 void VCoordinateSystem::createAxesShapes()
 478 {
 479     for (auto const& elem : m_aAxisMap)
 480     {
 481         VAxisBase* pVAxis = elem.second.get();
 482         if( pVAxis )
 483         {
 484             if(pVAxis->getDimensionCount()==2)
 485                 pVAxis->setTransformationSceneToScreen( m_aMatrixSceneToScreen );
 486
 487             tFullAxisIndex aFullAxisIndex = elem.first;
 488             if( aFullAxisIndex.second == 0 )
 489             {
 490                 if( aFullAxisIndex.first == 0 )
 491                 {
 492                     if( m_aExplicitScales[1].AxisType!=AxisType::CATEGORY )
 493                         pVAxis->setExtraLinePositionAtOtherAxis(
 494                             m_aExplicitScales[1].Origin );
 495                 }
 496                 else if( aFullAxisIndex.first == 1 )
 497                 {
 498                     if( m_aExplicitScales[0].AxisType!=AxisType::CATEGORY )
 499                         pVAxis->setExtraLinePositionAtOtherAxis(
 500                             m_aExplicitScales[0].Origin );
 501                 }
 502             }
 503
 504             pVAxis->createShapes();
 505         }
 506     }
 507 }
 508 void VCoordinateSystem::createGridShapes()
 509 {
 510 }
 511 void VCoordinateSystem::addMinimumAndMaximumSupplier( MinimumAndMaximumSupplier* pMinimumAndMaximumSupplier )
 512 {
 513     m_aMergedMinMaxSupplier.addMinimumAndMaximumSupplier(pMinimumAndMaximumSupplier);
 514 }
 515
 516 bool VCoordinateSystem::hasMinimumAndMaximumSupplier( MinimumAndMaximumSupplier* pMinimumAndMaximumSupplier )
 517 {
 518     return m_aMergedMinMaxSupplier.hasMinimumAndMaximumSupplier(pMinimumAndMaximumSupplier);
 519 }
 520
 521 void VCoordinateSystem::clearMinimumAndMaximumSupplierList()
 522 {
 523     m_aMergedMinMaxSupplier.clearMinimumAndMaximumSupplierList();
 524 }
 525
 526 bool VCoordinateSystem::getPropertySwapXAndYAxis() const
 527 {
 528     Reference<beans::XPropertySet> xProp(m_xCooSysModel, uno::UNO_QUERY );
 529     bool bSwapXAndY = false;
 530     if( xProp.is()) try
 531     {
 532         xProp->getPropertyValue( "SwapXAndYAxis" ) >>= bSwapXAndY;
 533     }
 534     catch( const uno::Exception& )
 535     {
 536         TOOLS_WARN_EXCEPTION("chart2", "" );
 537     }
 538     return bSwapXAndY;
 539 }
 540
 541 bool VCoordinateSystem::needSeriesNamesForAxis() const
 542 {
 543     return ( m_xCooSysModel.is() && m_xCooSysModel->getDimension() == 3 );
 544 }
 545 void VCoordinateSystem::setSeriesNamesForAxis( const Sequence< OUString >& rSeriesNames )
 546 {
 547     m_aSeriesNamesForZAxis = rSeriesNames;
 548 }
 549
 550 sal_Int32 VCoordinateSystem::getNumberFormatKeyForAxis(
 551         const Reference< chart2::XAxis >& xAxis
 552         , const Reference<chart2::XChartDocument>& xChartDoc)
 553 {
 554     return ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
 555                 xAxis, m_xCooSysModel, xChartDoc);
 556 }
 557
 558 } //namespace chart
 559
 560 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */