Line data Source code
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 "AxisHelper.hxx"
21 : #include "DiagramHelper.hxx"
22 : #include "ChartTypeHelper.hxx"
23 : #include "macros.hxx"
24 : #include "AxisIndexDefines.hxx"
25 : #include "LinePropertiesHelper.hxx"
26 : #include "ContainerHelper.hxx"
27 : #include "servicenames_coosystems.hxx"
28 : #include "DataSeriesHelper.hxx"
29 : #include "Scaling.hxx"
30 : #include "ChartModelHelper.hxx"
31 : #include "DataSourceHelper.hxx"
32 : #include <unonames.hxx>
33 :
34 : #include <unotools/saveopt.hxx>
35 :
36 : #include <com/sun/star/chart/ChartAxisPosition.hpp>
37 :
38 : #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
39 : #include <com/sun/star/chart2/XChartTypeContainer.hpp>
40 : #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
41 : #include <com/sun/star/chart2/data/XDataSource.hpp>
42 :
43 : #include <rtl/ustrbuf.hxx>
44 : #include <rtl/math.hxx>
45 :
46 : #include <com/sun/star/util/XCloneable.hpp>
47 : #include <com/sun/star/lang/XServiceName.hpp>
48 :
49 : #include <map>
50 :
51 : namespace chart
52 : {
53 : using namespace ::com::sun::star;
54 : using namespace ::com::sun::star::chart2;
55 : using ::com::sun::star::uno::Reference;
56 : using ::com::sun::star::uno::Sequence;
57 :
58 298 : Reference< chart2::XScaling > AxisHelper::createLinearScaling()
59 : {
60 298 : return new LinearScaling( 1.0, 0.0 );
61 : }
62 :
63 3 : Reference< chart2::XScaling > AxisHelper::createLogarithmicScaling( double fBase )
64 : {
65 3 : return new LogarithmicScaling( fBase );
66 : }
67 :
68 7103 : ScaleData AxisHelper::createDefaultScale()
69 : {
70 7103 : ScaleData aScaleData;
71 7103 : aScaleData.AxisType = chart2::AxisType::REALNUMBER;
72 7103 : aScaleData.AutoDateAxis = true;
73 7103 : aScaleData.ShiftedCategoryPosition = false;//this is adapted in the view code currently
74 14206 : Sequence< SubIncrement > aSubIncrements(1);
75 7103 : aSubIncrements[0] = SubIncrement();
76 7103 : aScaleData.IncrementData.SubIncrements = aSubIncrements;
77 14206 : return aScaleData;
78 : }
79 :
80 3669 : void AxisHelper::removeExplicitScaling( ScaleData& rScaleData )
81 : {
82 3669 : uno::Any aEmpty;
83 3669 : rScaleData.Minimum = rScaleData.Maximum = rScaleData.Origin = aEmpty;
84 3669 : rScaleData.Scaling = 0;
85 7338 : ScaleData aDefaultScale( createDefaultScale() );
86 3669 : rScaleData.IncrementData = aDefaultScale.IncrementData;
87 7338 : rScaleData.TimeIncrement = aDefaultScale.TimeIncrement;
88 3669 : }
89 :
90 7734 : bool AxisHelper::isLogarithmic( const Reference< XScaling >& xScaling )
91 : {
92 7734 : Reference< lang::XServiceName > xServiceName( xScaling, uno::UNO_QUERY );
93 7734 : return xServiceName.is()
94 15468 : && xServiceName->getServiceName() == "com.sun.star.chart2.LogarithmicScaling";
95 : }
96 :
97 3538 : chart2::ScaleData AxisHelper::getDateCheckedScale( const Reference< chart2::XAxis >& xAxis, ChartModel& rModel )
98 : {
99 3538 : ScaleData aScale = xAxis->getScaleData();
100 7076 : Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( rModel ) );
101 3538 : if( aScale.AutoDateAxis && aScale.AxisType == AxisType::CATEGORY )
102 : {
103 1838 : sal_Int32 nDimensionIndex=0; sal_Int32 nAxisIndex=0;
104 1838 : AxisHelper::getIndicesForAxis(xAxis, xCooSys, nDimensionIndex, nAxisIndex );
105 1838 : bool bChartTypeAllowsDateAxis = ChartTypeHelper::isSupportingDateAxis( AxisHelper::getChartTypeByIndex( xCooSys, 0 ), 2, nDimensionIndex );
106 1838 : if( bChartTypeAllowsDateAxis )
107 1805 : aScale.AxisType = AxisType::DATE;
108 : }
109 3538 : if( aScale.AxisType == AxisType::DATE )
110 : {
111 1805 : ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys, rModel );
112 1805 : if( !aExplicitCategoriesProvider.isDateAxis() )
113 1805 : aScale.AxisType = AxisType::CATEGORY;
114 : }
115 7076 : return aScale;
116 : }
117 :
118 2117 : void AxisHelper::checkDateAxis( chart2::ScaleData& rScale, ExplicitCategoriesProvider* pExplicitCategoriesProvider, bool bChartTypeAllowsDateAxis )
119 : {
120 2117 : if( rScale.AutoDateAxis && rScale.AxisType == AxisType::CATEGORY && bChartTypeAllowsDateAxis )
121 : {
122 1815 : rScale.AxisType = AxisType::DATE;
123 1815 : removeExplicitScaling( rScale );
124 : }
125 2117 : if( rScale.AxisType == AxisType::DATE && (!pExplicitCategoriesProvider || !pExplicitCategoriesProvider->isDateAxis()) )
126 : {
127 1815 : rScale.AxisType = AxisType::CATEGORY;
128 1815 : removeExplicitScaling( rScale );
129 : }
130 2117 : }
131 :
132 3857 : sal_Int32 AxisHelper::getExplicitNumberFormatKeyForAxis(
133 : const Reference< chart2::XAxis >& xAxis
134 : , const Reference< chart2::XCoordinateSystem > & xCorrespondingCoordinateSystem
135 : , const Reference<chart2::XChartDocument>& xChartDoc
136 : , bool bSearchForParallelAxisIfNothingIsFound )
137 : {
138 3857 : sal_Int32 nNumberFormatKey(0);
139 3857 : sal_Int32 nAxisIndex = 0;
140 3857 : sal_Int32 nDimensionIndex = 1;
141 3857 : AxisHelper::getIndicesForAxis( xAxis, xCorrespondingCoordinateSystem, nDimensionIndex, nAxisIndex );
142 3857 : Reference<util::XNumberFormatsSupplier> const xNumberFormatsSupplier(xChartDoc, uno::UNO_QUERY);
143 :
144 7714 : Reference< beans::XPropertySet > xProp( xAxis, uno::UNO_QUERY );
145 3857 : if (!xProp.is())
146 1 : return 0;
147 :
148 3856 : bool bLinkToSource = true;
149 3856 : xProp->getPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT) >>= bLinkToSource;
150 3856 : xProp->getPropertyValue(CHART_UNONAME_NUMFMT) >>= nNumberFormatKey;
151 :
152 3856 : sal_Int32 nOldNumberFormat = nNumberFormatKey;
153 :
154 3856 : if (bLinkToSource)
155 : {
156 3538 : bool bFormatSet = false;
157 : //check whether we have a percent scale -> use percent format
158 3538 : ChartModel* pModel = NULL;
159 3538 : if( xNumberFormatsSupplier.is() )
160 : {
161 3538 : pModel = dynamic_cast<ChartModel*>( xChartDoc.get() );
162 : assert(pModel);
163 : }
164 3538 : if (pModel)
165 : {
166 3538 : ScaleData aData = AxisHelper::getDateCheckedScale( xAxis, *pModel );
167 3538 : if( aData.AxisType==AxisType::PERCENT )
168 : {
169 2 : sal_Int32 nPercentFormat = DiagramHelper::getPercentNumberFormat( xNumberFormatsSupplier );
170 2 : if( nPercentFormat != -1 )
171 : {
172 2 : nNumberFormatKey = nPercentFormat;
173 2 : bFormatSet = true;
174 : }
175 : }
176 3536 : else if( aData.AxisType==AxisType::DATE )
177 : {
178 0 : if( aData.Categories.is() )
179 : {
180 0 : Reference< data::XDataSequence > xSeq( aData.Categories->getValues());
181 0 : if( xSeq.is() && !( xChartDoc.is() && xChartDoc->hasInternalDataProvider()) )
182 0 : nNumberFormatKey = xSeq->getNumberFormatKeyByIndex( -1 );
183 : else
184 0 : nNumberFormatKey = DiagramHelper::getDateNumberFormat( xNumberFormatsSupplier );
185 0 : bFormatSet = true;
186 : }
187 : }
188 3536 : else if( xChartDoc.is() && xChartDoc->hasInternalDataProvider() && nDimensionIndex == 0 ) //maybe date axis
189 : {
190 2042 : Reference< chart2::XDiagram > xDiagram( xChartDoc->getFirstDiagram() );
191 2042 : if( DiagramHelper::isSupportingDateAxis( xDiagram ) )
192 : {
193 1747 : nNumberFormatKey = DiagramHelper::getDateNumberFormat( xNumberFormatsSupplier );
194 : }
195 : else
196 : {
197 295 : Reference< data::XDataSource > xSource( DataSourceHelper::getUsedData( xChartDoc ) );
198 295 : if( xSource.is() )
199 : {
200 : ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aXValues(
201 295 : DataSeriesHelper::getAllDataSequencesByRole( xSource->getDataSequences(), "values-x", true ) );
202 295 : if( aXValues.empty() )
203 : {
204 256 : Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
205 256 : if( xCategories.is() )
206 : {
207 256 : Reference< data::XDataSequence > xSeq( xCategories->getValues());
208 256 : if( xSeq.is() )
209 : {
210 256 : bool bHasValidDoubles = false;
211 256 : double fTest=0.0;
212 256 : Sequence< uno::Any > aCats( xSeq->getData() );
213 256 : sal_Int32 nCount = aCats.getLength();
214 1594 : for( sal_Int32 i = 0; i < nCount; ++i )
215 : {
216 1338 : if( (aCats[i]>>=fTest) && !::rtl::math::isNan(fTest) )
217 : {
218 0 : bHasValidDoubles=true;
219 0 : break;
220 : }
221 : }
222 256 : if( bHasValidDoubles )
223 0 : nNumberFormatKey = DiagramHelper::getDateNumberFormat( xNumberFormatsSupplier );
224 256 : }
225 256 : }
226 295 : }
227 295 : }
228 : }
229 2042 : bFormatSet = true;
230 3538 : }
231 : }
232 :
233 3538 : if( !bFormatSet )
234 : {
235 : typedef ::std::map< sal_Int32, sal_Int32 > tNumberformatFrequency;
236 1494 : tNumberformatFrequency aKeyMap;
237 1494 : bool bNumberFormatKeyFoundViaAttachedData = false;
238 :
239 : try
240 : {
241 1494 : Reference< XChartTypeContainer > xCTCnt( xCorrespondingCoordinateSystem, uno::UNO_QUERY_THROW );
242 1494 : if( xCTCnt.is() )
243 : {
244 1494 : OUString aRoleToMatch;
245 1494 : if( nDimensionIndex == 0 )
246 225 : aRoleToMatch = "values-x";
247 2988 : Sequence< Reference< XChartType > > aChartTypes( xCTCnt->getChartTypes());
248 2994 : for( sal_Int32 nCTIdx=0; nCTIdx<aChartTypes.getLength(); ++nCTIdx )
249 : {
250 1500 : if( nDimensionIndex != 0 )
251 1269 : aRoleToMatch = ChartTypeHelper::getRoleOfSequenceForYAxisNumberFormatDetection( aChartTypes[nCTIdx] );
252 1500 : Reference< XDataSeriesContainer > xDSCnt( aChartTypes[nCTIdx], uno::UNO_QUERY_THROW );
253 3000 : Sequence< Reference< XDataSeries > > aDataSeriesSeq( xDSCnt->getDataSeries());
254 5870 : for( sal_Int32 nSeriesIdx=0; nSeriesIdx<aDataSeriesSeq.getLength(); ++nSeriesIdx )
255 : {
256 4370 : Reference< chart2::XDataSeries > xDataSeries(aDataSeriesSeq[nSeriesIdx]);
257 8736 : Reference< data::XDataSource > xSource( xDataSeries, uno::UNO_QUERY_THROW );
258 :
259 4370 : if( nDimensionIndex == 1 )
260 : {
261 : //only take those series into accoutn that are attached to this axis
262 2204 : sal_Int32 nAttachedAxisIndex = DataSeriesHelper::getAttachedAxisIndex(xDataSeries);
263 2204 : if( nAttachedAxisIndex != nAxisIndex )
264 4 : continue;
265 : }
266 :
267 : Reference< data::XLabeledDataSequence > xLabeledSeq(
268 8732 : DataSeriesHelper::getDataSequenceByRole( xSource, aRoleToMatch ) );
269 :
270 4366 : if( !xLabeledSeq.is() && nDimensionIndex==0 )
271 : {
272 858 : ScaleData aData = xAxis->getScaleData();
273 858 : xLabeledSeq = aData.Categories;
274 : }
275 :
276 4366 : if( xLabeledSeq.is() )
277 : {
278 4189 : Reference< data::XDataSequence > xSeq( xLabeledSeq->getValues());
279 4189 : if( xSeq.is() )
280 : {
281 4189 : sal_Int32 nKey = xSeq->getNumberFormatKeyByIndex( -1 );
282 : // initialize the value
283 4189 : if( aKeyMap.find( nKey ) == aKeyMap.end())
284 1409 : aKeyMap[ nKey ] = 0;
285 : // increase frequency
286 4189 : aKeyMap[ nKey ] = (aKeyMap[ nKey ] + 1);
287 4189 : }
288 : }
289 4366 : }
290 2994 : }
291 1494 : }
292 : }
293 0 : catch( const uno::Exception & ex )
294 : {
295 : ASSERT_EXCEPTION( ex );
296 : }
297 :
298 1494 : if( ! aKeyMap.empty())
299 : {
300 1409 : sal_Int32 nMaxFreq = 0;
301 : // find most frequent key
302 8454 : for( tNumberformatFrequency::const_iterator aIt = aKeyMap.begin();
303 5636 : aIt != aKeyMap.end(); ++aIt )
304 : {
305 : SAL_INFO(
306 : "chart2.tools",
307 : "NumberFormatKey " << (*aIt).first << " appears "
308 : << (*aIt).second << " times");
309 : // all values must at least be 1
310 1409 : if( (*aIt).second > nMaxFreq )
311 : {
312 1409 : nNumberFormatKey = (*aIt).first;
313 1409 : bNumberFormatKeyFoundViaAttachedData = true;
314 1409 : nMaxFreq = (*aIt).second;
315 : }
316 : }
317 : }
318 :
319 1494 : if( bSearchForParallelAxisIfNothingIsFound )
320 : {
321 : //no format is set to this axis and no data is set to this axis
322 : //--> try to obtain the format from the parallel y-axis
323 1440 : if( !bNumberFormatKeyFoundViaAttachedData && nDimensionIndex == 1 )
324 : {
325 1 : sal_Int32 nParallelAxisIndex = (nAxisIndex==1) ?0 :1;
326 1 : Reference< XAxis > xParallelAxis( AxisHelper::getAxis( 1, nParallelAxisIndex, xCorrespondingCoordinateSystem ) );
327 1 : nNumberFormatKey = AxisHelper::getExplicitNumberFormatKeyForAxis(xParallelAxis, xCorrespondingCoordinateSystem, xChartDoc, false);
328 : }
329 1494 : }
330 : }
331 :
332 3538 : if (nOldNumberFormat != nNumberFormatKey)
333 98 : xProp->setPropertyValue(CHART_UNONAME_NUMFMT, uno::makeAny(nNumberFormatKey));
334 : }
335 :
336 7713 : return nNumberFormatKey;
337 : }
338 :
339 9 : Reference< XAxis > AxisHelper::createAxis(
340 : sal_Int32 nDimensionIndex
341 : , sal_Int32 nAxisIndex // 0==main or 1==secondary axis
342 : , const Reference< XCoordinateSystem >& xCooSys
343 : , const Reference< uno::XComponentContext > & xContext
344 : , ReferenceSizeProvider * pRefSizeProvider )
345 : {
346 9 : if( !xContext.is() || !xCooSys.is() )
347 0 : return NULL;
348 9 : if( nDimensionIndex >= xCooSys->getDimension() )
349 0 : return NULL;
350 :
351 18 : Reference< XAxis > xAxis( xContext->getServiceManager()->createInstanceWithContext(
352 9 : "com.sun.star.chart2.Axis", xContext ), uno::UNO_QUERY );
353 :
354 : OSL_ASSERT( xAxis.is());
355 9 : if( xAxis.is())
356 : {
357 9 : xCooSys->setAxisByDimension( nDimensionIndex, xAxis, nAxisIndex );
358 :
359 9 : if( nAxisIndex>0 )//when inserting secondary axes copy some things from the main axis
360 : {
361 9 : ::com::sun::star::chart::ChartAxisPosition eNewAxisPos( ::com::sun::star::chart::ChartAxisPosition_END );
362 :
363 9 : Reference< XAxis > xMainAxis( xCooSys->getAxisByDimension( nDimensionIndex, 0 ) );
364 9 : if( xMainAxis.is() )
365 : {
366 9 : ScaleData aScale = xAxis->getScaleData();
367 18 : ScaleData aMainScale = xMainAxis->getScaleData();
368 :
369 9 : aScale.AxisType = aMainScale.AxisType;
370 9 : aScale.AutoDateAxis = aMainScale.AutoDateAxis;
371 9 : aScale.Categories = aMainScale.Categories;
372 9 : aScale.Orientation = aMainScale.Orientation;
373 :
374 9 : xAxis->setScaleData( aScale );
375 :
376 : //ensure that the second axis is not placed on the main axis
377 18 : Reference< beans::XPropertySet > xMainProp( xMainAxis, uno::UNO_QUERY );
378 9 : if( xMainProp.is() )
379 : {
380 9 : ::com::sun::star::chart::ChartAxisPosition eMainAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO );
381 9 : xMainProp->getPropertyValue("CrossoverPosition") >>= eMainAxisPos;
382 9 : if( ::com::sun::star::chart::ChartAxisPosition_END == eMainAxisPos )
383 1 : eNewAxisPos = ::com::sun::star::chart::ChartAxisPosition_START;
384 9 : }
385 : }
386 :
387 18 : Reference< beans::XPropertySet > xProp( xAxis, uno::UNO_QUERY );
388 9 : if( xProp.is() )
389 18 : xProp->setPropertyValue("CrossoverPosition", uno::makeAny(eNewAxisPos) );
390 : }
391 :
392 9 : Reference< beans::XPropertySet > xProp( xAxis, uno::UNO_QUERY );
393 9 : if( xProp.is() ) try
394 : {
395 : // set correct initial AutoScale
396 9 : if( pRefSizeProvider )
397 0 : pRefSizeProvider->setValuesAtPropertySet( xProp );
398 : }
399 0 : catch( const uno::Exception& e )
400 : {
401 : ASSERT_EXCEPTION( e );
402 9 : }
403 : }
404 9 : return xAxis;
405 : }
406 :
407 9 : Reference< XAxis > AxisHelper::createAxis( sal_Int32 nDimensionIndex, bool bMainAxis
408 : , const Reference< chart2::XDiagram >& xDiagram
409 : , const Reference< uno::XComponentContext >& xContext
410 : , ReferenceSizeProvider * pRefSizeProvider )
411 : {
412 : OSL_ENSURE( xContext.is(), "need a context to create an axis" );
413 9 : if( !xContext.is() )
414 0 : return NULL;
415 :
416 9 : sal_Int32 nAxisIndex = bMainAxis ? MAIN_AXIS_INDEX : SECONDARY_AXIS_INDEX;
417 9 : sal_Int32 nCooSysIndex = 0;
418 9 : Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
419 :
420 : // create axis
421 : return AxisHelper::createAxis(
422 9 : nDimensionIndex, nAxisIndex, xCooSys, xContext, pRefSizeProvider );
423 : }
424 :
425 155 : void AxisHelper::showAxis( sal_Int32 nDimensionIndex, bool bMainAxis
426 : , const Reference< chart2::XDiagram >& xDiagram
427 : , const Reference< uno::XComponentContext >& xContext
428 : , ReferenceSizeProvider * pRefSizeProvider )
429 : {
430 155 : if( !xDiagram.is() )
431 155 : return;
432 :
433 155 : bool bNewAxisCreated = false;
434 155 : Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
435 155 : if( !xAxis.is() && xContext.is() )
436 : {
437 : // create axis
438 9 : bNewAxisCreated = true;
439 9 : xAxis.set( AxisHelper::createAxis( nDimensionIndex, bMainAxis, xDiagram, xContext, pRefSizeProvider ) );
440 : }
441 :
442 : OSL_ASSERT( xAxis.is());
443 155 : if( !bNewAxisCreated ) //default is true already if created
444 146 : AxisHelper::makeAxisVisible( xAxis );
445 : }
446 :
447 90 : void AxisHelper::showGrid( sal_Int32 nDimensionIndex, sal_Int32 nCooSysIndex, bool bMainGrid
448 : , const Reference< XDiagram >& xDiagram
449 : , const Reference< uno::XComponentContext >& /*xContext*/ )
450 : {
451 90 : if( !xDiagram.is() )
452 0 : return;
453 :
454 90 : Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
455 90 : if(!xCooSys.is())
456 0 : return;
457 :
458 180 : Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, MAIN_AXIS_INDEX, xCooSys ) );
459 90 : if(!xAxis.is())
460 : {
461 : //hhhh todo create axis without axis visibility
462 : }
463 90 : if(!xAxis.is())
464 0 : return;
465 :
466 90 : if( bMainGrid )
467 85 : AxisHelper::makeGridVisible( xAxis->getGridProperties() );
468 : else
469 : {
470 5 : Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
471 10 : for( sal_Int32 nN=0; nN<aSubGrids.getLength(); nN++)
472 10 : AxisHelper::makeGridVisible( aSubGrids[nN] );
473 90 : }
474 : }
475 :
476 146 : void AxisHelper::makeAxisVisible( const Reference< XAxis >& xAxis )
477 : {
478 146 : Reference< beans::XPropertySet > xProps( xAxis, uno::UNO_QUERY );
479 146 : if( xProps.is() )
480 : {
481 146 : xProps->setPropertyValue( "Show", uno::makeAny( sal_True ) );
482 146 : LinePropertiesHelper::SetLineVisible( xProps );
483 146 : xProps->setPropertyValue( "DisplayLabels", uno::makeAny( sal_True ) );
484 146 : }
485 146 : }
486 :
487 211 : void AxisHelper::makeGridVisible( const Reference< beans::XPropertySet >& xGridProperties )
488 : {
489 211 : if( xGridProperties.is() )
490 : {
491 211 : xGridProperties->setPropertyValue( "Show", uno::makeAny( sal_True ) );
492 211 : LinePropertiesHelper::SetLineVisible( xGridProperties );
493 : }
494 211 : }
495 :
496 172 : void AxisHelper::hideAxis( sal_Int32 nDimensionIndex, bool bMainAxis
497 : , const Reference< XDiagram >& xDiagram )
498 : {
499 172 : AxisHelper::makeAxisInvisible( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
500 172 : }
501 :
502 172 : void AxisHelper::makeAxisInvisible( const Reference< XAxis >& xAxis )
503 : {
504 172 : Reference< beans::XPropertySet > xProps( xAxis, uno::UNO_QUERY );
505 172 : if( xProps.is() )
506 : {
507 172 : xProps->setPropertyValue( "Show", uno::makeAny( sal_False ) );
508 172 : }
509 172 : }
510 :
511 0 : void AxisHelper::hideAxisIfNoDataIsAttached( const Reference< XAxis >& xAxis, const Reference< XDiagram >& xDiagram )
512 : {
513 : //axis is hidden if no data is attached anymore but data is available
514 0 : bool bOtherSeriesAttachedToThisAxis = false;
515 0 : ::std::vector< Reference< chart2::XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
516 0 : ::std::vector< Reference< chart2::XDataSeries > >::const_iterator aIt = aSeriesVector.begin();
517 0 : for( ; aIt != aSeriesVector.end(); ++aIt)
518 : {
519 0 : uno::Reference< chart2::XAxis > xCurrentAxis( DiagramHelper::getAttachedAxis( *aIt, xDiagram ), uno::UNO_QUERY );
520 0 : if( xCurrentAxis==xAxis )
521 : {
522 0 : bOtherSeriesAttachedToThisAxis = true;
523 0 : break;
524 : }
525 0 : }
526 0 : if(!bOtherSeriesAttachedToThisAxis && !aSeriesVector.empty() )
527 0 : AxisHelper::makeAxisInvisible( xAxis );
528 0 : }
529 :
530 86 : void AxisHelper::hideGrid( sal_Int32 nDimensionIndex, sal_Int32 nCooSysIndex, bool bMainGrid
531 : , const Reference< XDiagram >& xDiagram )
532 : {
533 86 : if( !xDiagram.is() )
534 0 : return;
535 :
536 86 : Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
537 86 : if(!xCooSys.is())
538 0 : return;
539 :
540 172 : Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, MAIN_AXIS_INDEX, xCooSys ) );
541 86 : if(!xAxis.is())
542 0 : return;
543 :
544 86 : if( bMainGrid )
545 86 : AxisHelper::makeGridInvisible( xAxis->getGridProperties() );
546 : else
547 : {
548 0 : Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
549 0 : for( sal_Int32 nN=0; nN<aSubGrids.getLength(); nN++)
550 0 : AxisHelper::makeGridInvisible( aSubGrids[nN] );
551 86 : }
552 : }
553 :
554 86 : void AxisHelper::makeGridInvisible( const Reference< beans::XPropertySet >& xGridProperties )
555 : {
556 86 : if( xGridProperties.is() )
557 : {
558 86 : xGridProperties->setPropertyValue( "Show", uno::makeAny( sal_False ) );
559 : }
560 86 : }
561 :
562 9022 : bool AxisHelper::isGridShown( sal_Int32 nDimensionIndex, sal_Int32 nCooSysIndex, bool bMainGrid
563 : , const Reference< ::com::sun::star::chart2::XDiagram >& xDiagram )
564 : {
565 9022 : bool bRet = false;
566 :
567 9022 : Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
568 9022 : if(!xCooSys.is())
569 120 : return bRet;
570 :
571 17804 : Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, MAIN_AXIS_INDEX, xCooSys ) );
572 8902 : if(!xAxis.is())
573 2416 : return bRet;
574 :
575 6486 : if( bMainGrid )
576 3369 : bRet = AxisHelper::isGridVisible( xAxis->getGridProperties() );
577 : else
578 : {
579 3117 : Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
580 3117 : if( aSubGrids.getLength() )
581 3117 : bRet = AxisHelper::isGridVisible( aSubGrids[0] );
582 : }
583 :
584 15508 : return bRet;
585 : }
586 :
587 219098 : Reference< XCoordinateSystem > AxisHelper::getCoordinateSystemByIndex(
588 : const Reference< XDiagram >& xDiagram, sal_Int32 nIndex )
589 : {
590 219098 : Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
591 219098 : if(!xCooSysContainer.is())
592 198 : return NULL;
593 437800 : Sequence< Reference< XCoordinateSystem > > aCooSysList = xCooSysContainer->getCoordinateSystems();
594 218900 : if(0<=nIndex && nIndex<aCooSysList.getLength())
595 218868 : return aCooSysList[nIndex];
596 219130 : return NULL;
597 : }
598 :
599 203734 : Reference< XAxis > AxisHelper::getAxis( sal_Int32 nDimensionIndex, bool bMainAxis
600 : , const Reference< XDiagram >& xDiagram )
601 : {
602 203734 : Reference< XAxis > xRet;
603 : try
604 : {
605 203734 : Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, 0 );
606 203734 : xRet.set( AxisHelper::getAxis( nDimensionIndex, bMainAxis ? 0 : 1, xCooSys ) );
607 : }
608 0 : catch( const uno::Exception & )
609 : {
610 : }
611 203734 : return xRet;
612 : }
613 :
614 228833 : Reference< XAxis > AxisHelper::getAxis( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex
615 : , const Reference< XCoordinateSystem >& xCooSys )
616 : {
617 228833 : Reference< XAxis > xRet;
618 228833 : if(!xCooSys.is())
619 110 : return xRet;
620 :
621 228723 : if(nDimensionIndex >= xCooSys->getDimension())
622 5978 : return xRet;
623 :
624 222745 : if(nAxisIndex > xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex))
625 7613 : return xRet;
626 :
627 : assert(nAxisIndex >= 0);
628 : assert(nDimensionIndex >= 0);
629 215132 : xRet.set( xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex ) );
630 215132 : return xRet;
631 : }
632 :
633 4237 : Reference< XAxis > AxisHelper::getCrossingMainAxis( const Reference< XAxis >& xAxis
634 : , const Reference< XCoordinateSystem >& xCooSys )
635 : {
636 4237 : sal_Int32 nDimensionIndex = 0;
637 4237 : sal_Int32 nAxisIndex = 0;
638 4237 : AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex );
639 4237 : if( 2==nDimensionIndex )
640 : {
641 49 : nDimensionIndex=1;
642 49 : bool bSwapXY = false;
643 49 : Reference< beans::XPropertySet > xCooSysProp( xCooSys, uno::UNO_QUERY );
644 49 : if( xCooSysProp.is() && (xCooSysProp->getPropertyValue( "SwapXAndYAxis" ) >>= bSwapXY) && bSwapXY )
645 14 : nDimensionIndex=0;
646 : }
647 4188 : else if( 1==nDimensionIndex )
648 3140 : nDimensionIndex=0;
649 : else
650 1048 : nDimensionIndex=1;
651 4237 : return AxisHelper::getAxis( nDimensionIndex, 0, xCooSys );
652 : }
653 :
654 0 : Reference< XAxis > AxisHelper::getParallelAxis( const Reference< XAxis >& xAxis
655 : , const Reference< XDiagram >& xDiagram )
656 : {
657 : try
658 : {
659 0 : sal_Int32 nCooSysIndex=-1;
660 0 : sal_Int32 nDimensionIndex=-1;
661 0 : sal_Int32 nAxisIndex=-1;
662 0 : if( getIndicesForAxis( xAxis, xDiagram, nCooSysIndex, nDimensionIndex, nAxisIndex ) )
663 : {
664 0 : sal_Int32 nParallelAxisIndex = (nAxisIndex==1) ?0 :1;
665 0 : return getAxis( nDimensionIndex, nParallelAxisIndex, getCoordinateSystemByIndex( xDiagram, nCooSysIndex ) );
666 : }
667 : }
668 0 : catch( const uno::RuntimeException& )
669 : {
670 : }
671 0 : return 0;
672 : }
673 :
674 3393 : bool AxisHelper::isAxisShown( sal_Int32 nDimensionIndex, bool bMainAxis
675 : , const Reference< XDiagram >& xDiagram )
676 : {
677 3393 : return AxisHelper::isAxisVisible( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
678 : }
679 :
680 4975 : bool AxisHelper::isAxisVisible( const Reference< XAxis >& xAxis )
681 : {
682 4975 : bool bRet = false;
683 :
684 4975 : Reference< beans::XPropertySet > xProps( xAxis, uno::UNO_QUERY );
685 4975 : if( xProps.is() )
686 : {
687 3329 : xProps->getPropertyValue( "Show" ) >>= bRet;
688 6045 : bRet = bRet && ( LinePropertiesHelper::IsLineVisible( xProps )
689 3523 : || areAxisLabelsVisible( xProps ) );
690 : }
691 :
692 4975 : return bRet;
693 : }
694 :
695 194 : bool AxisHelper::areAxisLabelsVisible( const Reference< beans::XPropertySet >& xAxisProperties )
696 : {
697 194 : bool bRet = false;
698 194 : if( xAxisProperties.is() )
699 : {
700 194 : xAxisProperties->getPropertyValue( "DisplayLabels" ) >>= bRet;
701 : }
702 194 : return bRet;
703 : }
704 :
705 13812 : bool AxisHelper::isGridVisible( const Reference< beans::XPropertySet >& xGridProperies )
706 : {
707 13812 : bool bRet = false;
708 :
709 13812 : if( xGridProperies.is() )
710 : {
711 13812 : xGridProperies->getPropertyValue( "Show" ) >>= bRet;
712 13812 : bRet = bRet && LinePropertiesHelper::IsLineVisible( xGridProperies );
713 : }
714 :
715 13812 : return bRet;
716 : }
717 :
718 6157 : Reference< beans::XPropertySet > AxisHelper::getGridProperties(
719 : const Reference< XCoordinateSystem >& xCooSys
720 : , sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex, sal_Int32 nSubGridIndex )
721 : {
722 6157 : Reference< beans::XPropertySet > xRet;
723 :
724 12314 : Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, nAxisIndex, xCooSys ) );
725 6157 : if( xAxis.is() )
726 : {
727 6157 : if( nSubGridIndex<0 )
728 5382 : xRet.set( xAxis->getGridProperties() );
729 : else
730 : {
731 775 : Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
732 775 : if( nSubGridIndex >= 0 && nSubGridIndex < aSubGrids.getLength() )
733 775 : xRet.set( aSubGrids[nSubGridIndex] );
734 : }
735 : }
736 :
737 12314 : return xRet;
738 : }
739 :
740 0 : sal_Int32 AxisHelper::getDimensionIndexOfAxis(
741 : const Reference< XAxis >& xAxis
742 : , const Reference< XDiagram >& xDiagram )
743 : {
744 0 : sal_Int32 nDimensionIndex = -1;
745 0 : sal_Int32 nCooSysIndex = -1;
746 0 : sal_Int32 nAxisIndex = -1;
747 0 : AxisHelper::getIndicesForAxis( xAxis, xDiagram, nCooSysIndex , nDimensionIndex, nAxisIndex );
748 0 : return nDimensionIndex;
749 : }
750 :
751 33423 : bool AxisHelper::getIndicesForAxis(
752 : const Reference< XAxis >& xAxis
753 : , const Reference< XCoordinateSystem >& xCooSys
754 : , sal_Int32& rOutDimensionIndex, sal_Int32& rOutAxisIndex )
755 : {
756 : //returns true if indices are found
757 :
758 33423 : rOutDimensionIndex = -1;
759 33423 : rOutAxisIndex = -1;
760 :
761 33423 : if( xCooSys.is() && xAxis.is() )
762 : {
763 33422 : Reference< XAxis > xCurrentAxis;
764 33422 : sal_Int32 nDimensionCount( xCooSys->getDimension() );
765 53922 : for( sal_Int32 nDimensionIndex = 0; nDimensionIndex < nDimensionCount; nDimensionIndex++ )
766 : {
767 53922 : sal_Int32 nMaxAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
768 76445 : for( sal_Int32 nAxisIndex = 0; nAxisIndex <= nMaxAxisIndex; nAxisIndex++ )
769 : {
770 55945 : xCurrentAxis = xCooSys->getAxisByDimension(nDimensionIndex,nAxisIndex);
771 55945 : if( xCurrentAxis == xAxis )
772 : {
773 33422 : rOutDimensionIndex = nDimensionIndex;
774 33422 : rOutAxisIndex = nAxisIndex;
775 33422 : return true;
776 : }
777 : }
778 0 : }
779 : }
780 1 : return false;
781 : }
782 :
783 3581 : bool AxisHelper::getIndicesForAxis( const Reference< XAxis >& xAxis, const Reference< XDiagram >& xDiagram
784 : , sal_Int32& rOutCooSysIndex, sal_Int32& rOutDimensionIndex, sal_Int32& rOutAxisIndex )
785 : {
786 : //returns true if indices are found
787 :
788 3581 : rOutCooSysIndex = -1;
789 3581 : rOutDimensionIndex = -1;
790 3581 : rOutAxisIndex = -1;
791 :
792 3581 : Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
793 3581 : if(xCooSysContainer.is())
794 : {
795 3581 : Sequence< Reference< XCoordinateSystem > > aCooSysList = xCooSysContainer->getCoordinateSystems();
796 3581 : for( sal_Int32 nC=0; nC<aCooSysList.getLength(); ++nC )
797 : {
798 3581 : if( AxisHelper::getIndicesForAxis( xAxis, aCooSysList[nC], rOutDimensionIndex, rOutAxisIndex ) )
799 : {
800 3581 : rOutCooSysIndex = nC;
801 3581 : return true;
802 : }
803 0 : }
804 : }
805 :
806 0 : return false;
807 : }
808 :
809 18884 : std::vector< Reference< XAxis > > AxisHelper::getAllAxesOfCoordinateSystem(
810 : const Reference< XCoordinateSystem >& xCooSys
811 : , bool bOnlyVisible /* = false */ )
812 : {
813 18884 : std::vector< Reference< XAxis > > aAxisVector;
814 :
815 18884 : if(xCooSys.is())
816 : {
817 18884 : sal_Int32 nMaxDimensionIndex = xCooSys->getDimension() -1;
818 18884 : if( nMaxDimensionIndex>=0 )
819 : {
820 18884 : sal_Int32 nDimensionIndex = 0;
821 63388 : for(; nDimensionIndex<=nMaxDimensionIndex; ++nDimensionIndex)
822 : {
823 44504 : const sal_Int32 nMaximumAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
824 92336 : for(sal_Int32 nAxisIndex=0; nAxisIndex<=nMaximumAxisIndex; ++nAxisIndex)
825 : {
826 : try
827 : {
828 47832 : Reference< XAxis > xAxis( xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex ) );
829 47832 : if( xAxis.is() )
830 : {
831 47832 : bool bAddAxis = true;
832 47832 : if( bOnlyVisible )
833 : {
834 1582 : Reference< beans::XPropertySet > xAxisProp( xAxis, uno::UNO_QUERY );
835 6328 : if( !xAxisProp.is() ||
836 6328 : !(xAxisProp->getPropertyValue( "Show") >>= bAddAxis) )
837 0 : bAddAxis = false;
838 : }
839 47832 : if( bAddAxis )
840 47727 : aAxisVector.push_back( xAxis );
841 47832 : }
842 : }
843 0 : catch( const uno::Exception & ex )
844 : {
845 : ASSERT_EXCEPTION( ex );
846 : }
847 : }
848 : }
849 : }
850 : }
851 :
852 18884 : return aAxisVector;
853 : }
854 :
855 2384 : Sequence< Reference< XAxis > > AxisHelper::getAllAxesOfDiagram(
856 : const Reference< XDiagram >& xDiagram
857 : , bool bOnlyVisible )
858 : {
859 2384 : std::vector< Reference< XAxis > > aAxisVector;
860 :
861 4768 : Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
862 2384 : if(xCooSysContainer.is())
863 : {
864 2384 : Sequence< Reference< XCoordinateSystem > > aCooSysList = xCooSysContainer->getCoordinateSystems();
865 2384 : sal_Int32 nC = 0;
866 4762 : for( nC=0; nC<aCooSysList.getLength(); ++nC )
867 : {
868 2378 : std::vector< Reference< XAxis > > aAxesPerCooSys( AxisHelper::getAllAxesOfCoordinateSystem( aCooSysList[nC], bOnlyVisible ) );
869 2378 : aAxisVector.insert( aAxisVector.end(), aAxesPerCooSys.begin(), aAxesPerCooSys.end() );
870 4762 : }
871 : }
872 :
873 4768 : return ContainerHelper::ContainerToSequence( aAxisVector );
874 : }
875 :
876 0 : Sequence< Reference< beans::XPropertySet > > AxisHelper::getAllGrids( const Reference< XDiagram >& xDiagram )
877 : {
878 0 : Sequence< Reference< XAxis > > aAllAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
879 0 : std::vector< Reference< beans::XPropertySet > > aGridVector;
880 :
881 0 : sal_Int32 nA = 0;
882 0 : for( nA=0; nA<aAllAxes.getLength(); ++nA )
883 : {
884 0 : Reference< XAxis > xAxis( aAllAxes[nA] );
885 0 : if(!xAxis.is())
886 0 : continue;
887 0 : Reference< beans::XPropertySet > xGridProperties( xAxis->getGridProperties() );
888 0 : if( xGridProperties.is() )
889 0 : aGridVector.push_back( xGridProperties );
890 :
891 0 : Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );;
892 0 : sal_Int32 nSubGrid = 0;
893 0 : for( nSubGrid = 0; nSubGrid < aSubGrids.getLength(); ++nSubGrid )
894 : {
895 0 : Reference< beans::XPropertySet > xSubGrid( aSubGrids[nSubGrid] );
896 0 : if( xSubGrid.is() )
897 0 : aGridVector.push_back( xSubGrid );
898 0 : }
899 0 : }
900 :
901 0 : return ContainerHelper::ContainerToSequence( aGridVector );
902 : }
903 :
904 0 : void AxisHelper::getAxisOrGridPossibilities( Sequence< sal_Bool >& rPossibilityList
905 : , const Reference< XDiagram>& xDiagram, bool bAxis )
906 : {
907 0 : rPossibilityList.realloc(6);
908 :
909 0 : sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
910 :
911 : //set possibilities:
912 0 : sal_Int32 nIndex=0;
913 0 : Reference< XChartType > xChartType = DiagramHelper::getChartTypeByIndex( xDiagram, 0 );
914 0 : for(nIndex=0;nIndex<3;nIndex++)
915 0 : rPossibilityList[nIndex]=ChartTypeHelper::isSupportingMainAxis(xChartType,nDimensionCount,nIndex);
916 0 : for(nIndex=3;nIndex<6;nIndex++)
917 0 : if( bAxis )
918 0 : rPossibilityList[nIndex]=ChartTypeHelper::isSupportingSecondaryAxis(xChartType,nDimensionCount,nIndex-3);
919 : else
920 0 : rPossibilityList[nIndex] = rPossibilityList[nIndex-3];
921 0 : }
922 :
923 121 : bool AxisHelper::isSecondaryYAxisNeeded( const Reference< XCoordinateSystem >& xCooSys )
924 : {
925 121 : Reference< chart2::XChartTypeContainer > xCTCnt( xCooSys, uno::UNO_QUERY );
926 121 : if( xCTCnt.is() )
927 : {
928 121 : Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes() );
929 121 : for( sal_Int32 i=0; i<aChartTypes.getLength(); ++i )
930 : {
931 0 : Reference< XDataSeriesContainer > xSeriesContainer( aChartTypes[i] , uno::UNO_QUERY );
932 0 : if( !xSeriesContainer.is() )
933 0 : continue;
934 :
935 0 : Sequence< Reference< XDataSeries > > aSeriesList( xSeriesContainer->getDataSeries() );
936 0 : for( sal_Int32 nS = aSeriesList.getLength(); nS-- ; )
937 : {
938 0 : Reference< beans::XPropertySet > xProp( aSeriesList[nS], uno::UNO_QUERY );
939 0 : if(xProp.is())
940 : {
941 0 : sal_Int32 nAttachedAxisIndex = 0;
942 0 : if( ( xProp->getPropertyValue( "AttachedAxisIndex" ) >>= nAttachedAxisIndex ) && nAttachedAxisIndex>0 )
943 0 : return true;
944 : }
945 0 : }
946 121 : }
947 : }
948 121 : return false;
949 : }
950 :
951 4370 : bool AxisHelper::shouldAxisBeDisplayed( const Reference< XAxis >& xAxis
952 : , const Reference< XCoordinateSystem >& xCooSys )
953 : {
954 4370 : bool bRet = false;
955 :
956 4370 : if( xAxis.is() && xCooSys.is() )
957 : {
958 4370 : sal_Int32 nDimensionIndex=-1;
959 4370 : sal_Int32 nAxisIndex=-1;
960 4370 : if( AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex ) )
961 : {
962 4370 : sal_Int32 nDimensionCount = xCooSys->getDimension();
963 4370 : Reference< XChartType > xChartType( AxisHelper::getChartTypeByIndex( xCooSys, 0 ) );
964 :
965 4370 : bool bMainAxis = (nAxisIndex==MAIN_AXIS_INDEX);
966 4370 : if( bMainAxis )
967 4322 : bRet = ChartTypeHelper::isSupportingMainAxis(xChartType,nDimensionCount,nDimensionIndex);
968 : else
969 48 : bRet = ChartTypeHelper::isSupportingSecondaryAxis(xChartType,nDimensionCount,nDimensionIndex);
970 : }
971 : }
972 :
973 4370 : return bRet;
974 : }
975 :
976 0 : void AxisHelper::getAxisOrGridExcistence( Sequence< sal_Bool >& rExistenceList
977 : , const Reference< XDiagram>& xDiagram, bool bAxis )
978 : {
979 0 : rExistenceList.realloc(6);
980 :
981 0 : if(bAxis)
982 : {
983 : sal_Int32 nN;
984 0 : Reference< XAxis > xAxis;
985 0 : for(nN=0;nN<3;nN++)
986 0 : rExistenceList[nN] = AxisHelper::isAxisShown( nN, true, xDiagram );
987 0 : for(nN=3;nN<6;nN++)
988 0 : rExistenceList[nN] = AxisHelper::isAxisShown( nN%3, false, xDiagram );
989 : }
990 : else
991 : {
992 : sal_Int32 nN;
993 :
994 0 : for(nN=0;nN<3;nN++)
995 0 : rExistenceList[nN] = AxisHelper::isGridShown( nN, 0, true, xDiagram );
996 0 : for(nN=3;nN<6;nN++)
997 0 : rExistenceList[nN] = AxisHelper::isGridShown( nN%3, 0, false, xDiagram );
998 : }
999 0 : }
1000 :
1001 0 : bool AxisHelper::changeVisibilityOfAxes( const Reference< XDiagram >& xDiagram
1002 : , const Sequence< sal_Bool >& rOldExistenceList
1003 : , const Sequence< sal_Bool >& rNewExistenceList
1004 : , const Reference< uno::XComponentContext >& xContext
1005 : , ReferenceSizeProvider * pRefSizeProvider )
1006 : {
1007 0 : bool bChanged = false;
1008 0 : for(sal_Int32 nN=0;nN<6;nN++)
1009 : {
1010 0 : if(rOldExistenceList[nN]!=rNewExistenceList[nN])
1011 : {
1012 0 : bChanged = true;
1013 0 : if(rNewExistenceList[nN])
1014 : {
1015 0 : AxisHelper::showAxis( nN%3, nN<3, xDiagram, xContext, pRefSizeProvider );
1016 : }
1017 : else
1018 0 : AxisHelper::hideAxis( nN%3, nN<3, xDiagram );
1019 : }
1020 : }
1021 0 : return bChanged;
1022 : }
1023 :
1024 0 : bool AxisHelper::changeVisibilityOfGrids( const Reference< XDiagram >& xDiagram
1025 : , const Sequence< sal_Bool >& rOldExistenceList
1026 : , const Sequence< sal_Bool >& rNewExistenceList
1027 : , const Reference< uno::XComponentContext >& xContext )
1028 : {
1029 0 : bool bChanged = false;
1030 0 : for(sal_Int32 nN=0;nN<6;nN++)
1031 : {
1032 0 : if(rOldExistenceList[nN]!=rNewExistenceList[nN])
1033 : {
1034 0 : bChanged = true;
1035 0 : if(rNewExistenceList[nN])
1036 0 : AxisHelper::showGrid( nN%3, 0, nN<3, xDiagram, xContext );
1037 : else
1038 0 : AxisHelper::hideGrid( nN%3, 0, nN<3, xDiagram );
1039 : }
1040 : }
1041 0 : return bChanged;
1042 : }
1043 :
1044 16506 : Reference< XCoordinateSystem > AxisHelper::getCoordinateSystemOfAxis(
1045 : const Reference< XAxis >& xAxis
1046 : , const Reference< XDiagram >& xDiagram )
1047 : {
1048 16506 : Reference< XCoordinateSystem > xRet;
1049 :
1050 33012 : Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
1051 16506 : if( xCooSysContainer.is() )
1052 : {
1053 16506 : Reference< XCoordinateSystem > xCooSys;
1054 33012 : Sequence< Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );
1055 16506 : for( sal_Int32 nCooSysIndex = 0; nCooSysIndex < aCooSysList.getLength(); ++nCooSysIndex )
1056 : {
1057 16506 : xCooSys = aCooSysList[nCooSysIndex];
1058 16506 : std::vector< Reference< XAxis > > aAllAxis( AxisHelper::getAllAxesOfCoordinateSystem( xCooSys ) );
1059 :
1060 : ::std::vector< Reference< XAxis > >::iterator aFound =
1061 16506 : ::std::find( aAllAxis.begin(), aAllAxis.end(), xAxis );
1062 16506 : if( aFound != aAllAxis.end())
1063 : {
1064 16506 : xRet.set( xCooSys );
1065 16506 : break;
1066 : }
1067 16506 : }
1068 : }
1069 33012 : return xRet;
1070 : }
1071 :
1072 10933 : Reference< XChartType > AxisHelper::getChartTypeByIndex( const Reference< XCoordinateSystem >& xCooSys, sal_Int32 nIndex )
1073 : {
1074 10933 : Reference< XChartType > xChartType;
1075 :
1076 21866 : Reference< XChartTypeContainer > xChartTypeContainer( xCooSys, uno::UNO_QUERY );
1077 10933 : if( xChartTypeContainer.is() )
1078 : {
1079 10933 : Sequence< Reference< XChartType > > aChartTypeList( xChartTypeContainer->getChartTypes() );
1080 10933 : if( nIndex >= 0 && nIndex < aChartTypeList.getLength() )
1081 10933 : xChartType.set( aChartTypeList[nIndex] );
1082 : }
1083 :
1084 21866 : return xChartType;
1085 : }
1086 :
1087 0 : void AxisHelper::setRTLAxisLayout( const Reference< XCoordinateSystem >& xCooSys )
1088 : {
1089 0 : if( xCooSys.is() )
1090 : {
1091 0 : bool bCartesian = xCooSys->getViewServiceName() == CHART2_COOSYSTEM_CARTESIAN_VIEW_SERVICE_NAME;
1092 0 : if( bCartesian )
1093 : {
1094 0 : bool bVertical = false;
1095 0 : Reference< beans::XPropertySet > xCooSysProp( xCooSys, uno::UNO_QUERY );
1096 0 : if( xCooSysProp.is() )
1097 0 : xCooSysProp->getPropertyValue( "SwapXAndYAxis" ) >>= bVertical;
1098 :
1099 0 : sal_Int32 nHorizontalAxisDimension = bVertical ? 1 : 0;
1100 0 : sal_Int32 nVerticalAxisDimension = bVertical ? 0 : 1;
1101 :
1102 : try
1103 : {
1104 : //reverse direction for horizontal main axis
1105 0 : Reference< chart2::XAxis > xHorizontalMainAxis( AxisHelper::getAxis( nHorizontalAxisDimension, MAIN_AXIS_INDEX, xCooSys ) );
1106 0 : if( xHorizontalMainAxis.is() )
1107 : {
1108 0 : chart2::ScaleData aScale = xHorizontalMainAxis->getScaleData();
1109 0 : aScale.Orientation = chart2::AxisOrientation_REVERSE;
1110 0 : xHorizontalMainAxis->setScaleData(aScale);
1111 : }
1112 :
1113 : //mathematical direction for vertical main axis
1114 0 : Reference< chart2::XAxis > xVerticalMainAxis( AxisHelper::getAxis( nVerticalAxisDimension, MAIN_AXIS_INDEX, xCooSys ) );
1115 0 : if( xVerticalMainAxis.is() )
1116 : {
1117 0 : chart2::ScaleData aScale = xVerticalMainAxis->getScaleData();
1118 0 : aScale.Orientation = chart2::AxisOrientation_MATHEMATICAL;
1119 0 : xVerticalMainAxis->setScaleData(aScale);
1120 0 : }
1121 : }
1122 0 : catch( const uno::Exception & ex )
1123 : {
1124 : ASSERT_EXCEPTION( ex );
1125 : }
1126 :
1127 : try
1128 : {
1129 : //reverse direction for horizontal secondary axis
1130 0 : Reference< chart2::XAxis > xHorizontalSecondaryAxis( AxisHelper::getAxis( nHorizontalAxisDimension, SECONDARY_AXIS_INDEX, xCooSys ) );
1131 0 : if( xHorizontalSecondaryAxis.is() )
1132 : {
1133 0 : chart2::ScaleData aScale = xHorizontalSecondaryAxis->getScaleData();
1134 0 : aScale.Orientation = chart2::AxisOrientation_REVERSE;
1135 0 : xHorizontalSecondaryAxis->setScaleData(aScale);
1136 : }
1137 :
1138 : //mathematical direction for vertical secondary axis
1139 0 : Reference< chart2::XAxis > xVerticalSecondaryAxis( AxisHelper::getAxis( nVerticalAxisDimension, SECONDARY_AXIS_INDEX, xCooSys ) );
1140 0 : if( xVerticalSecondaryAxis.is() )
1141 : {
1142 0 : chart2::ScaleData aScale = xVerticalSecondaryAxis->getScaleData();
1143 0 : aScale.Orientation = chart2::AxisOrientation_MATHEMATICAL;
1144 0 : xVerticalSecondaryAxis->setScaleData(aScale);
1145 0 : }
1146 : }
1147 0 : catch( const uno::Exception & ex )
1148 : {
1149 : ASSERT_EXCEPTION( ex );
1150 0 : }
1151 : }
1152 : }
1153 0 : }
1154 :
1155 0 : Reference< XChartType > AxisHelper::getFirstChartTypeWithSeriesAttachedToAxisIndex( const Reference< chart2::XDiagram >& xDiagram, const sal_Int32 nAttachedAxisIndex )
1156 : {
1157 0 : Reference< XChartType > xChartType;
1158 0 : ::std::vector< Reference< XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
1159 0 : ::std::vector< Reference< XDataSeries > >::const_iterator aIter = aSeriesVector.begin();
1160 0 : for( ; aIter != aSeriesVector.end(); ++aIter )
1161 : {
1162 0 : sal_Int32 nCurrentIndex = DataSeriesHelper::getAttachedAxisIndex( *aIter );
1163 0 : if( nAttachedAxisIndex == nCurrentIndex )
1164 : {
1165 0 : xChartType = DiagramHelper::getChartTypeOfSeries( xDiagram, *aIter );
1166 0 : if(xChartType.is())
1167 0 : break;
1168 : }
1169 : }
1170 0 : return xChartType;
1171 : }
1172 :
1173 10820 : bool AxisHelper::isAxisPositioningEnabled()
1174 : {
1175 10820 : const SvtSaveOptions::ODFDefaultVersion nCurrentVersion( SvtSaveOptions().GetODFDefaultVersion() );
1176 10820 : return nCurrentVersion >= SvtSaveOptions::ODFVER_012;
1177 : }
1178 :
1179 : } //namespace chart
1180 :
1181 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
