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