?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merged tag ooo/OOO330_m14
[LibreOffice.git] / chart2 / source / model / template / ChartTypeTemplate.cxx
blobe3943e9eb45fcb8589f0659df807af8725f54c1f
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2000, 2010 Oracle and/or its affiliates.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * This file is part of OpenOffice.org.
10 *
11 * OpenOffice.org is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License version 3
13 * only, as published by the Free Software Foundation.
14 *
15 * OpenOffice.org is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License version 3 for more details
19 * (a copy is included in the LICENSE file that accompanied this code).
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * version 3 along with OpenOffice.org. If not, see
23 * <http://www.openoffice.org/license.html>
24 * for a copy of the LGPLv3 License.
25 *
26 ************************************************************************/
27
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_chart2.hxx"
30 #include "ChartTypeTemplate.hxx"
31 #include "PropertyHelper.hxx"
32 #include "macros.hxx"
33 #include "DataSeriesHelper.hxx"
34 #include "DataInterpreter.hxx"
35 #include "CommonConverters.hxx"
36 #include "ContainerHelper.hxx"
37 #include "ChartTypeHelper.hxx"
38
39 #include "CartesianCoordinateSystem.hxx"
40 #include "AxisHelper.hxx"
41 #include "LegendHelper.hxx"
42 #include "DiagramHelper.hxx"
43 #include "ChartDebugTrace.hxx"
44 #include "AxisIndexDefines.hxx"
45 #include <cppuhelper/component_context.hxx>
46 #include <com/sun/star/chart/ChartSolidType.hpp>
47 #include <com/sun/star/chart2/AxisType.hpp>
48 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
49 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
50 #include <com/sun/star/chart2/AxisType.hpp>
51
52 #include <algorithm>
53 #include <iterator>
54
55 using namespace ::com::sun::star;
56 using namespace ::com::sun::star::chart2;
57
58 using ::rtl::OUString;
59 using ::com::sun::star::uno::Sequence;
60 using ::com::sun::star::uno::Reference;
61 using ::com::sun::star::uno::Any;
62
63 // ======================================================================
64
65 namespace
66 {
67
68 void lcl_applyDefaultStyle(
69 const Reference< XDataSeries > & xSeries,
70 sal_Int32 nIndex,
71 const Reference< XDiagram > & xDiagram )
72 {
73 // @deprecated: correct default color should be found by view without
74 // setting color as hard attribute
75 if( xSeries.is() && xDiagram.is())
76 {
77 Reference< beans::XPropertySet > xSeriesProp( xSeries, uno::UNO_QUERY );
78 Reference< chart2::XColorScheme > xColorScheme( xDiagram->getDefaultColorScheme());
79 if( xSeriesProp.is() && xColorScheme.is() )
80 xSeriesProp->setPropertyValue(
81 C2U("Color"),
82 uno::makeAny( xColorScheme->getColorByIndex( nIndex )));
83 }
84 }
85
86 void lcl_ensureCorrectLabelPlacement( const Reference< beans::XPropertySet >& xProp, const uno::Sequence < sal_Int32 >& rAvailablePlacements )
87 {
88 sal_Int32 nLabelPlacement=0;
89 if( xProp.is() && (xProp->getPropertyValue( C2U( "LabelPlacement" ) ) >>= nLabelPlacement) )
90 {
91 bool bValid = false;
92 for( sal_Int32 nN = 0; nN < rAvailablePlacements.getLength(); nN++ )
93 {
94 if( rAvailablePlacements[nN] == nLabelPlacement )
95 {
96 bValid = true;
97 break;
98 }
99 }
100 if( !bValid )
101 {
102 uno::Any aNewValue;
103 //otherwise use the first supported one
104 if( rAvailablePlacements.getLength() )
105 aNewValue <<=rAvailablePlacements[0];
106 xProp->setPropertyValue( C2U("LabelPlacement"), aNewValue );
107 }
108 }
109 }
110
111 void lcl_resetLabelPlacementIfDefault( const Reference< beans::XPropertySet >& xProp, sal_Int32 nDefaultPlacement )
112 {
113
114 sal_Int32 nLabelPlacement=0;
115 if( xProp.is() && (xProp->getPropertyValue( C2U( "LabelPlacement" ) ) >>= nLabelPlacement) )
116 {
117 if( nDefaultPlacement == nLabelPlacement )
118 xProp->setPropertyValue( C2U("LabelPlacement"), uno::Any() );
119 }
120 }
121
122 void lcl_ensureCorrectMissingValueTreatment( const Reference< chart2::XDiagram >& xDiagram, const Reference< XChartType >& xChartType )
123 {
124 Reference< beans::XPropertySet > xDiaProp( xDiagram, uno::UNO_QUERY );
125 if( xDiaProp.is() )
126 {
127 uno::Sequence < sal_Int32 > aAvailableMissingValueTreatment(
128 ::chart::ChartTypeHelper::getSupportedMissingValueTreatments( xChartType ) );
129
130 if( aAvailableMissingValueTreatment.getLength() )
131 xDiaProp->setPropertyValue( C2U( "MissingValueTreatment" ), uno::makeAny( aAvailableMissingValueTreatment[0] ) );
132 else
133 xDiaProp->setPropertyValue( C2U( "MissingValueTreatment" ), uno::Any() );
134 }
135 }
136
137 } // anonymous namespace
138
139 namespace chart
140 {
141
142 ChartTypeTemplate::ChartTypeTemplate(
143 Reference< uno::XComponentContext > const & xContext,
144 const ::rtl::OUString & rServiceName ) :
145 m_xContext( xContext ),
146 m_aServiceName( rServiceName )
147 {
148 }
149
150 ChartTypeTemplate::~ChartTypeTemplate()
151 {}
152
153 // ____ XChartTypeTemplate ____
154 uno::Reference< XDiagram > SAL_CALL ChartTypeTemplate::createDiagramByDataSource(
155 const uno::Reference< data::XDataSource >& xDataSource,
156 const uno::Sequence< beans::PropertyValue >& aArguments )
157 throw (uno::RuntimeException)
158 {
159 Reference< XDiagram > xDia;
160
161 try
162 {
163 // create diagram
164 xDia.set(
165 GetComponentContext()->getServiceManager()->createInstanceWithContext(
166 C2U( "com.sun.star.chart2.Diagram" ),
167 GetComponentContext() ),
168 uno::UNO_QUERY_THROW );
169
170 // modify diagram
171 Reference< chart2::XDataInterpreter > xInterpreter( getDataInterpreter());
172 chart2::InterpretedData aData(
173 xInterpreter->interpretDataSource(
174 xDataSource, aArguments, Sequence< Reference< XDataSeries > >() ));
175
176 Sequence< Sequence< Reference< XDataSeries > > > aSeries( aData.Series );
177 sal_Int32 i, j, nCount = 0;
178 for( i=0; i<aSeries.getLength(); ++i )
179 {
180 for( j=0; j<aSeries[i].getLength(); ++j, ++nCount )
181 lcl_applyDefaultStyle( aSeries[i][j], nCount, xDia );
182 }
183
184 Sequence< Reference< XChartType > > aOldChartTypesSeq;
185 FillDiagram( xDia, aData.Series, aData.Categories, aOldChartTypesSeq, true );
186 }
187 catch( uno::Exception & ex )
188 {
189 ASSERT_EXCEPTION( ex );
190 }
191
192 return xDia;
193 }
194
195 sal_Bool SAL_CALL ChartTypeTemplate::supportsCategories()
196 throw (uno::RuntimeException)
197 {
198 return sal_True;
199 }
200
201 void SAL_CALL ChartTypeTemplate::changeDiagram( const uno::Reference< XDiagram >& xDiagram )
202 throw (uno::RuntimeException)
203 {
204 if( ! xDiagram.is())
205 return;
206
207 try
208 {
209 Sequence< Sequence< Reference< XDataSeries > > > aSeriesSeq(
210 DiagramHelper::getDataSeriesGroups( xDiagram ));
211 Sequence< Reference< XDataSeries > > aFlatSeriesSeq( FlattenSequence( aSeriesSeq ));
212 const sal_Int32 nFormerSeriesCount = aFlatSeriesSeq.getLength();
213
214 // chart-type specific interpretation of existing data series
215 Reference< chart2::XDataInterpreter > xInterpreter( getDataInterpreter());
216 chart2::InterpretedData aData;
217 aData.Series = aSeriesSeq;
218 aData.Categories = DiagramHelper::getCategoriesFromDiagram( xDiagram );
219
220 if( xInterpreter->isDataCompatible( aData ) )
221 {
222 aData = xInterpreter->reinterpretDataSeries( aData );
223 }
224 else
225 {
226 Reference< data::XDataSource > xSource( xInterpreter->mergeInterpretedData( aData ));
227 // todo: get a "range-union" from the data provider by calling
228 // OUString aRange = getRangeRepresentationByData( xSource );
229 // xSource.set( getDataByRangeRepresentation( aRange, aParam ));
230 // where aParam == ??
231 Sequence< beans::PropertyValue > aParam;
232 if( aData.Categories.is())
233 {
234 aParam.realloc( 1 );
235 aParam[0] = beans::PropertyValue( C2U("HasCategories"), -1, uno::makeAny( true ),
236 beans::PropertyState_DIRECT_VALUE );
237 }
238 aData = xInterpreter->interpretDataSource( xSource, aParam, aFlatSeriesSeq );
239 }
240 aSeriesSeq = aData.Series;
241
242 sal_Int32 i, j, nIndex = 0;
243 for( i=0; i<aSeriesSeq.getLength(); ++i )
244 for( j=0; j<aSeriesSeq[i].getLength(); ++j, ++nIndex )
245 {
246 if( nIndex >= nFormerSeriesCount )
247 lcl_applyDefaultStyle( aSeriesSeq[i][j], nIndex, xDiagram );
248 }
249
250 // remove charttype groups from all coordinate systems
251 Sequence< Reference< XChartType > > aOldChartTypesSeq(
252 DiagramHelper::getChartTypesFromDiagram(xDiagram) );
253
254 Reference< XCoordinateSystemContainer > xCoordSysCnt( xDiagram, uno::UNO_QUERY );
255 OSL_ASSERT( xCoordSysCnt.is());
256 if( xCoordSysCnt.is())
257 {
258 Sequence< Reference< XCoordinateSystem > > aCooSysSeq(
259 xCoordSysCnt->getCoordinateSystems());
260 for( sal_Int32 nCooSysIdx = 0; nCooSysIdx < aCooSysSeq.getLength(); ++nCooSysIdx )
261 {
262 Reference< XChartTypeContainer > xContainer( aCooSysSeq[nCooSysIdx], uno::UNO_QUERY );
263 if( xContainer.is() )
264 xContainer->setChartTypes( Sequence< Reference< XChartType > >() );
265 }
266 }
267
268 FillDiagram( xDiagram, aSeriesSeq, aData.Categories, aOldChartTypesSeq, false );
269 }
270 catch( uno::Exception & ex )
271 {
272 ASSERT_EXCEPTION( ex );
273 }
274 }
275
276 void SAL_CALL ChartTypeTemplate::changeDiagramData(
277 const Reference< chart2::XDiagram >& xDiagram,
278 const Reference< chart2::data::XDataSource >& xDataSource,
279 const Sequence< beans::PropertyValue >& aArguments )
280 throw (uno::RuntimeException)
281 {
282 if( ! (xDiagram.is() &&
283 xDataSource.is()) )
284 return;
285
286 try
287 {
288 // interpret new data and re-use existing series
289 Sequence< Reference< XDataSeries > > aFlatSeriesSeq(
290 ::chart::ContainerHelper::ContainerToSequence( DiagramHelper::getDataSeriesFromDiagram( xDiagram )));
291 const sal_Int32 nFormerSeriesCount = aFlatSeriesSeq.getLength();
292 Reference< chart2::XDataInterpreter > xInterpreter( getDataInterpreter());
293 chart2::InterpretedData aData =
294 xInterpreter->interpretDataSource( xDataSource, aArguments, aFlatSeriesSeq );
295
296 // data series
297 Sequence< Sequence< Reference< XDataSeries > > > aSeriesSeq( aData.Series );
298
299 sal_Int32 i, j, nIndex = 0;
300 for( i=0; i<aSeriesSeq.getLength(); ++i )
301 for( j=0; j<aSeriesSeq[i].getLength(); ++j, ++nIndex )
302 {
303 if( nIndex >= nFormerSeriesCount )
304 {
305 lcl_applyDefaultStyle( aSeriesSeq[i][j], nIndex, xDiagram );
306 applyStyle( aSeriesSeq[i][j], i, j, aSeriesSeq[i].getLength() );
307 }
308 }
309
310 // categories
311 DiagramHelper::setCategoriesToDiagram( aData.Categories, xDiagram, true, supportsCategories() );
312
313 Sequence< Reference< XChartType > > aChartTypes(
314 DiagramHelper::getChartTypesFromDiagram( xDiagram ));
315 sal_Int32 nMax = ::std::min( aChartTypes.getLength(), aSeriesSeq.getLength());
316 for( i=0; i<nMax; ++i )
317 {
318 Reference< XDataSeriesContainer > xDSCnt( aChartTypes[i], uno::UNO_QUERY_THROW );
319 xDSCnt->setDataSeries( aSeriesSeq[i] );
320 }
321 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL
322 OSL_TRACE( "ChartTypeTemplate::changeDiagramData: Showing Diagram structure" );
323 OSL_TRACE( "---------------------------------------------------------------" );
324 debug::ChartDebugTraceDiagram( xDiagram );
325 #endif
326 }
327 catch( uno::Exception & ex )
328 {
329 ASSERT_EXCEPTION( ex );
330 }
331 }
332
333 sal_Bool SAL_CALL ChartTypeTemplate::matchesTemplate(
334 const Reference< chart2::XDiagram >& xDiagram,
335 sal_Bool /* bAdaptProperties */ )
336 throw (uno::RuntimeException)
337 {
338 sal_Bool bResult = sal_False;
339
340 if( ! xDiagram.is())
341 return bResult;
342
343 try
344 {
345 Reference< XCoordinateSystemContainer > xCooSysCnt(
346 xDiagram, uno::UNO_QUERY_THROW );
347 Sequence< Reference< XCoordinateSystem > > aCooSysSeq(
348 xCooSysCnt->getCoordinateSystems());
349
350 // need to have at least one coordinate system
351 bResult = (aCooSysSeq.getLength() > 0);
352 if( bResult )
353 {
354 Sequence< Reference< XChartType > > aFormerlyUsedChartTypes;
355 const OUString aChartTypeToMatch( getChartTypeForNewSeries(aFormerlyUsedChartTypes)->getChartType());
356 const sal_Int32 nDimensionToMatch = getDimension();
357 for( sal_Int32 nCooSysIdx=0; bResult && (nCooSysIdx < aCooSysSeq.getLength()); ++nCooSysIdx )
358 {
359 // match dimension
360 bResult = bResult && (aCooSysSeq[nCooSysIdx]->getDimension() == nDimensionToMatch);
361
362 Reference< XChartTypeContainer > xCTCnt( aCooSysSeq[nCooSysIdx], uno::UNO_QUERY_THROW );
363 Sequence< Reference< XChartType > > aChartTypeSeq( xCTCnt->getChartTypes());
364 for( sal_Int32 nCTIdx=0; bResult && (nCTIdx < aChartTypeSeq.getLength()); ++nCTIdx )
365 {
366 // match chart type
367 bResult = bResult && aChartTypeSeq[nCTIdx]->getChartType().equals( aChartTypeToMatch );
368 bool bFound=false;
369 bool bAmbiguous=false;
370 // match stacking mode
371 bResult = bResult &&
372 ( DiagramHelper::getStackModeFromChartType(
373 aChartTypeSeq[nCTIdx], bFound, bAmbiguous,
374 aCooSysSeq[nCooSysIdx] )
375 == getStackMode( nCTIdx ) );
376 }
377 }
378 }
379 }
380 catch( uno::Exception & ex )
381 {
382 ASSERT_EXCEPTION( ex );
383 }
384
385 return bResult;
386 }
387
388 Reference< chart2::XDataInterpreter > SAL_CALL ChartTypeTemplate::getDataInterpreter()
389 throw (uno::RuntimeException)
390 {
391 if( ! m_xDataInterpreter.is())
392 m_xDataInterpreter.set( new DataInterpreter( GetComponentContext() ) );
393
394 return m_xDataInterpreter;
395 }
396
397 void SAL_CALL ChartTypeTemplate::applyStyle(
398 const Reference< chart2::XDataSeries >& xSeries,
399 ::sal_Int32 nChartTypeIndex,
400 ::sal_Int32 /* nSeriesIndex */,
401 ::sal_Int32 /* nSeriesCount */ )
402 throw (uno::RuntimeException)
403 {
404 // sset stacking mode
405 Reference< beans::XPropertySet > xSeriesProp( xSeries, uno::UNO_QUERY );
406 if( xSeriesProp.is())
407 {
408 try
409 {
410 StackMode eStackMode = getStackMode( nChartTypeIndex );
411 const uno::Any aPropValue = uno::makeAny(
412 ( (eStackMode == StackMode_Y_STACKED) ||
413 (eStackMode == StackMode_Y_STACKED_PERCENT) )
414 ? chart2::StackingDirection_Y_STACKING
415 : (eStackMode == StackMode_Z_STACKED )
416 ? chart2::StackingDirection_Z_STACKING
417 : chart2::StackingDirection_NO_STACKING );
418 xSeriesProp->setPropertyValue( C2U("StackingDirection"), aPropValue );
419
420 //ensure valid label placement
421 {
422 uno::Sequence < sal_Int32 > aAvailablePlacements( ChartTypeHelper::getSupportedLabelPlacements(
423 getChartTypeForIndex( nChartTypeIndex ), getDimension(), isSwapXAndY(), xSeries ) );
424 lcl_ensureCorrectLabelPlacement( xSeriesProp, aAvailablePlacements );
425
426 uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
427 if( xSeriesProp->getPropertyValue( C2U( "AttributedDataPoints" ) ) >>= aAttributedDataPointIndexList )
428 for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
429 lcl_ensureCorrectLabelPlacement( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]), aAvailablePlacements );
430 }
431 }
432 catch( const uno::Exception & ex )
433 {
434 ASSERT_EXCEPTION( ex );
435 }
436 }
437 }
438
439 void SAL_CALL ChartTypeTemplate::applyStyles( const Reference< chart2::XDiagram >& xDiagram )
440 throw (uno::RuntimeException)
441 {
442 // apply chart-type specific styles, like "symbols on" for example
443 Sequence< Sequence< Reference< XDataSeries > > > aNewSeriesSeq(
444 DiagramHelper::getDataSeriesGroups( xDiagram ));
445 for( sal_Int32 i=0; i<aNewSeriesSeq.getLength(); ++i )
446 {
447 const sal_Int32 nNumSeries = aNewSeriesSeq[i].getLength();
448 for( sal_Int32 j=0; j<nNumSeries; ++j )
449 applyStyle( aNewSeriesSeq[i][j], i, j, nNumSeries );
450 }
451
452 //ensure valid empty cell handling (for first chart type...)
453 lcl_ensureCorrectMissingValueTreatment( xDiagram, getChartTypeForIndex( 0 ) );
454 }
455
456 void SAL_CALL ChartTypeTemplate::resetStyles( const Reference< chart2::XDiagram >& xDiagram )
457 throw (uno::RuntimeException)
458 {
459 // reset number format if we had percent stacking on
460 sal_Bool bPercent = (getStackMode(0) == StackMode_Y_STACKED_PERCENT);
461 if( bPercent )
462 {
463 Sequence< Reference< chart2::XAxis > > aAxisSeq( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
464 for( sal_Int32 i=0; i<aAxisSeq.getLength(); ++i )
465 {
466 if( 1== AxisHelper::getDimensionIndexOfAxis( aAxisSeq[i], xDiagram ) )
467 {
468 Reference< beans::XPropertySet > xAxisProp( aAxisSeq[i], uno::UNO_QUERY );
469 if( xAxisProp.is())
470 {
471 // set number format to source format
472 uno::Any aValue( xAxisProp->getPropertyValue(C2U("NumberFormat")));
473 if( aValue.hasValue())
474 xAxisProp->setPropertyValue(C2U("NumberFormat"), uno::Any());
475 }
476 }
477 }
478 }
479
480 //reset label placement if default
481 {
482 uno::Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
483 if( xCooSysContainer.is() )
484 {
485 uno::Sequence< uno::Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );
486 for( sal_Int32 nCS = 0; nCS < aCooSysList.getLength(); ++nCS )
487 {
488 uno::Reference< XCoordinateSystem > xCooSys( aCooSysList[nCS] );
489
490 //iterate through all chart types in the current coordinate system
491 uno::Reference< XChartTypeContainer > xChartTypeContainer( xCooSys, uno::UNO_QUERY );
492 OSL_ASSERT( xChartTypeContainer.is());
493 if( !xChartTypeContainer.is() )
494 continue;
495 uno::Sequence< uno::Reference< XChartType > > aChartTypeList( xChartTypeContainer->getChartTypes() );
496 for( sal_Int32 nT = 0; nT < aChartTypeList.getLength(); ++nT )
497 {
498 uno::Reference< XChartType > xChartType( aChartTypeList[nT] );
499
500 //iterate through all series in this chart type
501 uno::Reference< XDataSeriesContainer > xDataSeriesContainer( xChartType, uno::UNO_QUERY );
502 OSL_ASSERT( xDataSeriesContainer.is());
503 if( !xDataSeriesContainer.is() )
504 continue;
505
506 uno::Sequence< uno::Reference< XDataSeries > > aSeriesList( xDataSeriesContainer->getDataSeries() );
507 for( sal_Int32 nS = 0; nS < aSeriesList.getLength(); ++nS )
508 {
509 Reference< XDataSeries > xSeries(aSeriesList[nS]);
510 Reference< beans::XPropertySet > xSeriesProp( xSeries, uno::UNO_QUERY );
511 if(!xSeries.is() || !xSeriesProp.is() )
512 continue;
513
514 uno::Sequence < sal_Int32 > aAvailablePlacements( ChartTypeHelper::getSupportedLabelPlacements(
515 xChartType, getDimension(), isSwapXAndY(), xSeries ) );
516 if(!aAvailablePlacements.getLength())
517 continue;
518
519 sal_Int32 nDefaultPlacement = aAvailablePlacements[0];
520
521 lcl_resetLabelPlacementIfDefault( xSeriesProp, nDefaultPlacement );
522
523 uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
524 if( xSeriesProp->getPropertyValue( C2U( "AttributedDataPoints" ) ) >>= aAttributedDataPointIndexList )
525 for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
526 lcl_resetLabelPlacementIfDefault( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]), nDefaultPlacement );
527 }
528 }
529 }
530 }
531 }
532
533 return;
534 }
535
536 // ____ XServiceName ____
537 ::rtl::OUString SAL_CALL ChartTypeTemplate::getServiceName()
538 throw (uno::RuntimeException)
539 {
540 return m_aServiceName;
541 }
542
543 // ________________________________________
544
545 sal_Int32 ChartTypeTemplate::getDimension() const
546 {
547 return 2;
548 }
549
550 StackMode ChartTypeTemplate::getStackMode( sal_Int32 /* nChartTypeIndex */ ) const
551 {
552 return StackMode_NONE;
553 }
554
555 bool ChartTypeTemplate::isSwapXAndY() const
556 {
557 return false;
558 }
559
560 // ________________________________________
561
562 void ChartTypeTemplate::createCoordinateSystems(
563 const Reference< chart2::XCoordinateSystemContainer > & xOutCooSysCnt )
564 {
565 if( ! xOutCooSysCnt.is())
566 return;
567 Sequence< Reference< XChartType > > aFormerlyUsedChartTypes;
568 Reference< XChartType > xChartType( getChartTypeForNewSeries(aFormerlyUsedChartTypes));
569 if( ! xChartType.is())
570 return;
571 Reference< XCoordinateSystem > xCooSys( xChartType->createCoordinateSystem( getDimension()));
572 if( ! xCooSys.is())
573 {
574 // chart type wants no coordinate systems
575 xOutCooSysCnt->setCoordinateSystems( Sequence< Reference< XCoordinateSystem > >());
576 return;
577 }
578 // #i69680# make grid of first y-axis visible (was in the CooSys CTOR before)
579 if( xCooSys->getDimension() >= 2 )
580 {
581 Reference< chart2::XAxis > xAxis( xCooSys->getAxisByDimension( 1, 0 ));
582 if( xAxis.is())
583 AxisHelper::makeGridVisible( xAxis->getGridProperties() );
584 }
585
586 Sequence< Reference< XCoordinateSystem > > aCoordinateSystems(
587 xOutCooSysCnt->getCoordinateSystems());
588
589 if( aCoordinateSystems.getLength())
590 {
591 bool bOk = true;
592 for( sal_Int32 i=0; bOk && i<aCoordinateSystems.getLength(); ++i )
593 bOk = bOk && ( xCooSys->getCoordinateSystemType().equals( aCoordinateSystems[i]->getCoordinateSystemType()) &&
594 (xCooSys->getDimension() == aCoordinateSystems[i]->getDimension()) );
595 // coordinate systems are ok
596 if( bOk )
597 return;
598 // there are coordinate systems but they do not fit. So overwrite them.
599 }
600
601 //copy as much info from former coordinate system as possible:
602 if( aCoordinateSystems.getLength() )
603 {
604 Reference< XCoordinateSystem > xOldCooSys( aCoordinateSystems[0] );
605 sal_Int32 nMaxDimensionCount = std::min( xCooSys->getDimension(), xOldCooSys->getDimension() );
606
607 for(sal_Int32 nDimensionIndex=0; nDimensionIndex<nMaxDimensionCount; nDimensionIndex++)
608 {
609 const sal_Int32 nMaximumAxisIndex = xOldCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
610 for(sal_Int32 nAxisIndex=0; nAxisIndex<=nMaximumAxisIndex; ++nAxisIndex)
611 {
612 uno::Reference< XAxis > xAxis( xOldCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex ) );
613 if( xAxis.is())
614 {
615 xCooSys->setAxisByDimension( nDimensionIndex, xAxis, nAxisIndex );
616 }
617 }
618 }
619 }
620
621 // set new coordinate systems
622 aCoordinateSystems.realloc( 1 );
623 aCoordinateSystems[0] = xCooSys;
624
625 xOutCooSysCnt->setCoordinateSystems( aCoordinateSystems );
626 }
627
628 void ChartTypeTemplate::adaptScales(
629 const Sequence< Reference< chart2::XCoordinateSystem > > & aCooSysSeq,
630 const Reference< data::XLabeledDataSequence > & xCategories //@todo: in future there may be more than one sequence of categories (e.g. charttype with categories at x and y axis )
631 )
632 {
633 bool bSupportsCategories( supportsCategories() );
634 for( sal_Int32 nCooSysIdx=0; nCooSysIdx<aCooSysSeq.getLength(); ++nCooSysIdx )
635 {
636 try
637 {
638 Reference< XCoordinateSystem > xCooSys( aCooSysSeq[nCooSysIdx] );
639 if( !xCooSys.is() )
640 continue;
641
642 // attach categories to first axis
643 sal_Int32 nDim( xCooSys->getDimension());
644 if( nDim > 0 )
645 {
646 const sal_Int32 nMaxIndex = xCooSys->getMaximumAxisIndexByDimension(0);
647 for(sal_Int32 nI=0; nI<=nMaxIndex; ++nI)
648 {
649 Reference< XAxis > xAxis( xCooSys->getAxisByDimension(0,nI) );
650 if( xAxis.is())
651 {
652 ScaleData aData( xAxis->getScaleData() );
653 aData.Categories = xCategories;
654 aData.AxisType = bSupportsCategories ? AxisType::CATEGORY : AxisType::REALNUMBER;
655 if( bSupportsCategories )
656 AxisHelper::removeExplicitScaling( aData );
657 xAxis->setScaleData( aData );
658 }
659 }
660 }
661 // set percent stacking mode at second axis
662 if( nDim > 1 )
663 {
664 const sal_Int32 nMaxIndex = xCooSys->getMaximumAxisIndexByDimension(1);
665 for(sal_Int32 nI=0; nI<=nMaxIndex; ++nI)
666 {
667 Reference< chart2::XAxis > xAxis( xCooSys->getAxisByDimension( 1,nI ));
668 if( xAxis.is())
669 {
670 sal_Bool bPercent = (getStackMode(0) == StackMode_Y_STACKED_PERCENT);
671 chart2::ScaleData aScaleData = xAxis->getScaleData();
672
673 if( bPercent != (aScaleData.AxisType==AxisType::PERCENT) )
674 {
675 if( bPercent )
676 aScaleData.AxisType = AxisType::PERCENT;
677 else
678 aScaleData.AxisType = AxisType::REALNUMBER;
679 xAxis->setScaleData( aScaleData );
680 }
681 }
682 }
683 }
684 }
685 catch( const uno::Exception & ex )
686 {
687 ASSERT_EXCEPTION( ex );
688 }
689 }
690 }
691
692 void ChartTypeTemplate::adaptDiagram( const Reference< XDiagram > & /* xDiagram */ )
693 {
694 return;
695 }
696
697 void ChartTypeTemplate::createAxes(
698 const Sequence< Reference< XCoordinateSystem > > & rCoordSys )
699 {
700 //create missing axes
701 if( rCoordSys.getLength() > 0 )
702 {
703 sal_Int32 nCooSysIdx = 0;
704 Reference< XCoordinateSystem > xCooSys( rCoordSys[nCooSysIdx] );
705 if(!xCooSys.is())
706 return;
707
708 //create main axis in first coordinate system
709 sal_Int32 nDimCount = xCooSys->getDimension();
710 sal_Int32 nDim=0;
711 for( nDim=0; nDim<nDimCount; ++nDim )
712 {
713 sal_Int32 nAxisCount = getAxisCountByDimension( nDim );
714 if( nDim == 1 &&
715 nAxisCount < 2 && AxisHelper::isSecondaryYAxisNeeded( xCooSys ))
716 nAxisCount = 2;
717 for( sal_Int32 nAxisIndex = 0; nAxisIndex < nAxisCount; ++nAxisIndex )
718 {
719 Reference< XAxis > xAxis = AxisHelper::getAxis( nDim, nAxisIndex, xCooSys );
720 if( !xAxis.is())
721 {
722 // create and add axis
723 xAxis.set( AxisHelper::createAxis(
724 nDim, nAxisIndex, xCooSys, GetComponentContext() ));
725 }
726 }
727 }
728 }
729 }
730
731 void ChartTypeTemplate::adaptAxes(
732 const Sequence< Reference< XCoordinateSystem > > & rCoordSys )
733 {
734 //adapt properties of exsisting axes and remove superfluous axes
735
736 if( rCoordSys.getLength() > 0 )
737 {
738 for( sal_Int32 nCooSysIdx=0; nCooSysIdx < rCoordSys.getLength(); ++nCooSysIdx )
739 {
740 Reference< XCoordinateSystem > xCooSys( rCoordSys[nCooSysIdx] );
741 if( !xCooSys.is() )
742 continue;
743 sal_Int32 nDimCount = xCooSys->getDimension();
744 for( sal_Int32 nDim=0; nDim<nDimCount; ++nDim )
745 {
746 sal_Int32 nMaxAxisIndex = xCooSys->getMaximumAxisIndexByDimension( nDim );
747 for( sal_Int32 nAxisIndex=0; nAxisIndex<=nMaxAxisIndex; nAxisIndex++ )
748 {
749 Reference< XAxis > xAxis( AxisHelper::getAxis( nDim, nAxisIndex, xCooSys ) );
750 if( !xAxis.is() )
751 continue;
752
753 if( nAxisIndex == MAIN_AXIS_INDEX || nAxisIndex == SECONDARY_AXIS_INDEX )
754 {
755 // adapt scales
756 sal_Bool bPercent = (getStackMode(0) == StackMode_Y_STACKED_PERCENT);
757 if( bPercent && nDim == 1 )
758 {
759 Reference< beans::XPropertySet > xAxisProp( xAxis, uno::UNO_QUERY );
760 if( xAxisProp.is())
761 {
762 // set number format to source format
763 uno::Any aValue( xAxisProp->getPropertyValue(C2U("NumberFormat")));
764 if( aValue.hasValue())
765 xAxisProp->setPropertyValue(C2U("NumberFormat"), uno::Any());
766 }
767 }
768 }
769 }
770 }
771 }
772 }
773 }
774
775 sal_Int32 ChartTypeTemplate::getAxisCountByDimension( sal_Int32 nDimension )
776 {
777 return (nDimension < getDimension()) ? 1 : 0;
778 }
779
780 void ChartTypeTemplate::FillDiagram(
781 const Reference< XDiagram >& xDiagram,
782 const Sequence< Sequence< Reference< XDataSeries > > >& aSeriesSeq,
783 Reference< data::XLabeledDataSequence > xCategories,
784 const Sequence< Reference< XChartType > >& aOldChartTypesSeq,
785 bool /* bCreate */ )
786 {
787 adaptDiagram( xDiagram );
788
789 try
790 {
791 // create coordinate systems and scales
792 Reference< XCoordinateSystemContainer > xCoordSysCnt( xDiagram, uno::UNO_QUERY_THROW );
793 createCoordinateSystems( xCoordSysCnt );
794 Sequence< Reference< XCoordinateSystem > > aCoordinateSystems( xCoordSysCnt->getCoordinateSystems());
795 createAxes( aCoordinateSystems );
796 adaptAxes( aCoordinateSystems );
797 adaptScales( aCoordinateSystems, xCategories );
798
799 // chart types
800 createChartTypes( aSeriesSeq, aCoordinateSystems, aOldChartTypesSeq );
801 applyStyles( xDiagram );
802 }
803 catch( const uno::Exception & ex )
804 {
805 ASSERT_EXCEPTION( ex );
806 }
807
808 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL
809 OSL_TRACE( "ChartTypeTemplate::FillDiagram: Showing Diagram structure" );
810 OSL_TRACE( "---------------------------------------------------------" );
811 debug::ChartDebugTraceDiagram( xDiagram );
812 #endif
813 }
814
815 void ChartTypeTemplate::createChartTypes(
816 const Sequence< Sequence< Reference< XDataSeries > > > & aSeriesSeq,
817 const Sequence< Reference< XCoordinateSystem > > & rCoordSys,
818 const Sequence< Reference< XChartType > >& aOldChartTypesSeq )
819 {
820 if( rCoordSys.getLength() == 0 ||
821 ! rCoordSys[0].is() )
822 return;
823
824 try
825 {
826 sal_Int32 nCooSysIdx=0;
827 Reference< XChartType > xCT;
828 if( aSeriesSeq.getLength() == 0 )
829 {
830 // we need a new chart type
831 xCT.set( getChartTypeForNewSeries( aOldChartTypesSeq ));
832 Reference< XChartTypeContainer > xCTCnt( rCoordSys[nCooSysIdx], uno::UNO_QUERY_THROW );
833 Sequence< Reference< XChartType > > aCTSeq( xCTCnt->getChartTypes());
834 aCTSeq.realloc( 1 );
835 aCTSeq[0] = xCT;
836 xCTCnt->setChartTypes( aCTSeq );
837 }
838 else
839 {
840 for( sal_Int32 nSeriesIdx=0; nSeriesIdx<aSeriesSeq.getLength(); ++nSeriesIdx )
841 {
842 if( nSeriesIdx == nCooSysIdx )
843 {
844 // we need a new chart type
845 xCT.set( getChartTypeForNewSeries( aOldChartTypesSeq ));
846 Reference< XChartTypeContainer > xCTCnt( rCoordSys[nCooSysIdx], uno::UNO_QUERY_THROW );
847 Sequence< Reference< XChartType > > aCTSeq( xCTCnt->getChartTypes());
848 if( aCTSeq.getLength())
849 {
850 aCTSeq[0] = xCT;
851 xCTCnt->setChartTypes( aCTSeq );
852 }
853 else
854 xCTCnt->addChartType( xCT );
855
856 Reference< chart2::XDataSeriesContainer > xDSCnt( xCT, uno::UNO_QUERY_THROW );
857 xDSCnt->setDataSeries( aSeriesSeq[nSeriesIdx] );
858 }
859 else
860 {
861 // reuse existing chart type
862 OSL_ASSERT( xCT.is());
863 Reference< chart2::XDataSeriesContainer > xDSCnt( xCT, uno::UNO_QUERY_THROW );
864 Sequence< Reference< XDataSeries > > aNewSeriesSeq( xDSCnt->getDataSeries());
865 sal_Int32 nNewStartIndex = aNewSeriesSeq.getLength();
866 aNewSeriesSeq.realloc( nNewStartIndex + aSeriesSeq[nSeriesIdx].getLength() );
867 ::std::copy( aSeriesSeq[nSeriesIdx].getConstArray(),
868 aSeriesSeq[nSeriesIdx].getConstArray() + aSeriesSeq[nSeriesIdx].getLength(),
869 aNewSeriesSeq.getArray() + nNewStartIndex );
870 xDSCnt->setDataSeries( aNewSeriesSeq );
871 }
872
873 // spread the series over the available coordinate systems
874 if( rCoordSys.getLength() > (nCooSysIdx + 1) )
875 ++nCooSysIdx;
876 }
877 }
878 }
879 catch( uno::Exception & ex )
880 {
881 ASSERT_EXCEPTION( ex );
882 }
883 }
884
885 //static
886 void ChartTypeTemplate::copyPropertiesFromOldToNewCoordianteSystem(
887 const Sequence< Reference< XChartType > > & rOldChartTypesSeq,
888 const Reference< XChartType > & xNewChartType )
889 {
890 Reference< beans::XPropertySet > xDestination( xNewChartType, uno::UNO_QUERY );
891 if( !xDestination.is() )
892 return;
893
894 OUString aNewChartType( xNewChartType->getChartType() );
895
896 Reference< beans::XPropertySet > xSource;
897 sal_Int32 nN=0;
898 for( nN=0; nN<rOldChartTypesSeq.getLength();++nN)
899 {
900 Reference< XChartType > xOldType( rOldChartTypesSeq[nN] );
901 if( xOldType.is() && xOldType->getChartType().equals( aNewChartType ) )
902 {
903 xSource.set( Reference< beans::XPropertySet >(xOldType, uno::UNO_QUERY ) );
904 if( xSource.is() )
905 break;
906 }
907 }
908 if( xSource.is() )
909 comphelper::copyProperties( xSource, xDestination );
910 }
911
912 // ________
913
914 Sequence< OUString > ChartTypeTemplate::getSupportedServiceNames_Static()
915 {
916 Sequence< OUString > aServices( 3 );
917 aServices[ 0 ] = C2U( "com.sun.star.chart2.ChartTypeTemplate" );
918 aServices[ 1 ] = C2U( "com.sun.star.layout.LayoutElement" );
919 aServices[ 2 ] = C2U( "com.sun.star.beans.PropertySet" );
920 return aServices;
921 }
922
923 Reference< uno::XComponentContext > ChartTypeTemplate::GetComponentContext() const
924 {
925 return m_xContext;
926 }
927
928 // ================================================================================
929
930 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
931 APPHELPER_XSERVICEINFO_IMPL( ChartTypeTemplate,
932 C2U( "com.sun.star.comp.chart.ChartTypeTemplate" ));
933 } // namespace chart
FREE OFFICE SUITE