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