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
createCoordinateSystem(const Reference<XCoordinateSystem> & xCooSysModel)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
VCoordinateSystem(const Reference<XCoordinateSystem> & xCooSys)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 }
~VCoordinateSystem()101 VCoordinateSystem::~VCoordinateSystem()
102 {
103 }
104
initPlottingTargets(const Reference<drawing::XShapes> & xLogicTarget,const Reference<drawing::XShapes> & xFinalTarget,const Reference<lang::XMultiServiceFactory> & xShapeFactory,Reference<drawing::XShapes> & xLogicTargetForSeriesBehindAxis)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
setParticle(const rtl::OUString & rCooSysParticle)134 void VCoordinateSystem::setParticle( const rtl::OUString& rCooSysParticle )
135 {
136 m_aCooSysParticle = rCooSysParticle;
137 }
138
setTransformationSceneToScreen(const drawing::HomogenMatrix & rMatrix)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
getTransformationSceneToScreen()158 drawing::HomogenMatrix VCoordinateSystem::getTransformationSceneToScreen()
159 {
160 return m_aMatrixSceneToScreen;
161 }
162
163 //better performance for big data
getCoordinateSystemResolution(const awt::Size & rPageSize,const awt::Size & rPageResolution)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
getModel() const216 Reference< XCoordinateSystem > VCoordinateSystem::getModel() const
217 {
218 return m_xCooSysModel;
219 }
220
getAxisByDimension(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex) const221 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
getGridListFromAxis(const Reference<XAxis> & xAxis)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
impl_adjustDimension(sal_Int32 & rDimensionIndex) const242 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
impl_adjustDimensionAndIndex(sal_Int32 & rDimensionIndex,sal_Int32 & rAxisIndex) const250 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
setExplicitCategoriesProvider(ExplicitCategoriesProvider * pExplicitCategoriesProvider)258 void VCoordinateSystem::setExplicitCategoriesProvider( ExplicitCategoriesProvider* pExplicitCategoriesProvider /*takes ownership*/ )
259 {
260 m_apExplicitCategoriesProvider = ::std::auto_ptr< ExplicitCategoriesProvider >(pExplicitCategoriesProvider);
261 }
262
getExplicitCategoriesProvider()263 ExplicitCategoriesProvider* VCoordinateSystem::getExplicitCategoriesProvider()
264 {
265 return m_apExplicitCategoriesProvider.get();
266 }
267
getExplicitScales(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex) const268 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
getExplicitIncrements(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex) const278 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
getExplicitScale(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex) const288 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
getExplicitIncrement(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex) const311 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
createCIDForAxis(const Reference<chart2::XAxis> &,sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex)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 }
createCIDForGrid(const Reference<chart2::XAxis> &,sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex)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
getMaximumAxisIndexByDimension(sal_Int32 nDimensionIndex) const345 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
createVAxisList(const uno::Reference<util::XNumberFormatsSupplier> &,const awt::Size &,const awt::Rectangle &)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
initVAxisInList()370 void VCoordinateSystem::initVAxisInList()
371 {
372 }
updateScalesAndIncrementsOnAxes()373 void VCoordinateSystem::updateScalesAndIncrementsOnAxes()
374 {
375 }
376
prepareScaleAutomatismForDimensionAndIndex(ScaleAutomatism & rScaleAutomatism,sal_Int32 nDimIndex,sal_Int32 nAxisIndex)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
getVAxis(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex)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
setExplicitScaleAndIncrement(sal_Int32 nDimensionIndex,sal_Int32 nAxisIndex,const ExplicitScaleData & rExplicitScale,const ExplicitIncrementData & rExplicitIncrement)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
set3DWallPositions(CuboidPlanePosition eLeftWallPos,CuboidPlanePosition eBackWallPos,CuboidPlanePosition eBottomPos)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
createMaximumAxesLabels()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 }
createAxesLabels()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
updatePositions()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
createAxesShapes()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 }
createGridShapes()546 void VCoordinateSystem::createGridShapes()
547 {
548 }
addMinimumAndMaximumSupplier(MinimumAndMaximumSupplier * pMinimumAndMaximumSupplier)549 void VCoordinateSystem::addMinimumAndMaximumSupplier( MinimumAndMaximumSupplier* pMinimumAndMaximumSupplier )
550 {
551 m_aMergedMinimumAndMaximumSupplier.addMinimumAndMaximumSupplier(pMinimumAndMaximumSupplier);
552 }
553
hasMinimumAndMaximumSupplier(MinimumAndMaximumSupplier * pMinimumAndMaximumSupplier)554 bool VCoordinateSystem::hasMinimumAndMaximumSupplier( MinimumAndMaximumSupplier* pMinimumAndMaximumSupplier )
555 {
556 return m_aMergedMinimumAndMaximumSupplier.hasMinimumAndMaximumSupplier(pMinimumAndMaximumSupplier);
557 }
558
clearMinimumAndMaximumSupplierList()559 void VCoordinateSystem::clearMinimumAndMaximumSupplierList()
560 {
561 m_aMergedMinimumAndMaximumSupplier.clearMinimumAndMaximumSupplierList();
562 }
563
getPropertySwapXAndYAxis() const564 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
needSeriesNamesForAxis() const579 bool VCoordinateSystem::needSeriesNamesForAxis() const
580 {
581 return ( m_xCooSysModel.is() && m_xCooSysModel->getDimension() == 3 );
582 }
setSeriesNamesForAxis(const Sequence<rtl::OUString> & rSeriesNames)583 void VCoordinateSystem::setSeriesNamesForAxis( const Sequence< rtl::OUString >& rSeriesNames )
584 {
585 m_aSeriesNamesForZAxis = rSeriesNames;
586 }
587
getNumberFormatKeyForAxis(const Reference<chart2::XAxis> & xAxis,const Reference<util::XNumberFormatsSupplier> & xNumberFormatsSupplier)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