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