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