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 :
21 : #include "ExplicitCategoriesProvider.hxx"
22 : #include "DiagramHelper.hxx"
23 : #include "ChartTypeHelper.hxx"
24 : #include "AxisHelper.hxx"
25 : #include "CommonConverters.hxx"
26 : #include "DataSourceHelper.hxx"
27 : #include "ChartModelHelper.hxx"
28 : #include "ContainerHelper.hxx"
29 : #include "macros.hxx"
30 : #include "NumberFormatterWrapper.hxx"
31 :
32 : #include <com/sun/star/chart2/AxisType.hpp>
33 : #include <com/sun/star/util/NumberFormat.hpp>
34 : #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
35 :
36 : //.............................................................................
37 : namespace chart
38 : {
39 : //.............................................................................
40 :
41 : using namespace ::com::sun::star;
42 : using namespace ::com::sun::star::chart2;
43 : using ::com::sun::star::uno::Reference;
44 : using ::com::sun::star::uno::Sequence;
45 : using ::rtl::OUString;
46 : using ::std::vector;
47 :
48 :
49 123 : ExplicitCategoriesProvider::ExplicitCategoriesProvider( const Reference< chart2::XCoordinateSystem >& xCooSysModel
50 : , const uno::Reference< frame::XModel >& xChartModel )
51 : : m_bDirty(true)
52 : , m_xCooSysModel( xCooSysModel )
53 : , m_xChartModel( xChartModel )
54 : , m_xOriginalCategories()
55 : , m_bIsExplicitCategoriesInited(false)
56 : , m_bIsDateAxis(false)
57 123 : , m_bIsAutoDate(false)
58 : {
59 : try
60 : {
61 123 : if( xCooSysModel.is() )
62 : {
63 123 : uno::Reference< XAxis > xAxis( xCooSysModel->getAxisByDimension(0,0) );
64 123 : if( xAxis.is() )
65 : {
66 123 : ScaleData aScale( xAxis->getScaleData() );
67 123 : m_xOriginalCategories = aScale.Categories;
68 123 : m_bIsAutoDate = (aScale.AutoDateAxis && aScale.AxisType==chart2::AxisType::CATEGORY);
69 123 : m_bIsDateAxis = (aScale.AxisType == chart2::AxisType::DATE || m_bIsAutoDate);
70 123 : }
71 : }
72 :
73 123 : if( m_xOriginalCategories.is() )
74 : {
75 123 : Reference< chart2::XChartDocument > xChartDoc( xChartModel, uno::UNO_QUERY );
76 123 : if( xChartDoc.is() )
77 : {
78 123 : uno::Reference< data::XDataProvider > xDataProvider( xChartDoc->getDataProvider() );
79 :
80 123 : OUString aCategoriesRange( DataSourceHelper::getRangeFromValues( m_xOriginalCategories ) );
81 123 : if( xDataProvider.is() && !aCategoriesRange.isEmpty() )
82 : {
83 123 : const bool bFirstCellAsLabel = false;
84 123 : const bool bHasCategories = false;
85 123 : const uno::Sequence< sal_Int32 > aSequenceMapping;
86 :
87 123 : uno::Reference< data::XDataSource > xColumnCategoriesSource( xDataProvider->createDataSource(
88 : DataSourceHelper::createArguments( aCategoriesRange, aSequenceMapping, true /*bUseColumns*/
89 123 : , bFirstCellAsLabel, bHasCategories ) ) );
90 :
91 123 : uno::Reference< data::XDataSource > xRowCategoriesSource( xDataProvider->createDataSource(
92 : DataSourceHelper::createArguments( aCategoriesRange, aSequenceMapping, false /*bUseColumns*/
93 123 : , bFirstCellAsLabel, bHasCategories ) ) );
94 :
95 123 : if( xColumnCategoriesSource.is() && xRowCategoriesSource.is() )
96 : {
97 123 : Sequence< Reference< data::XLabeledDataSequence> > aColumns = xColumnCategoriesSource->getDataSequences();
98 123 : Sequence< Reference< data::XLabeledDataSequence> > aRows = xRowCategoriesSource->getDataSequences();
99 :
100 123 : sal_Int32 nColumnCount = aColumns.getLength();
101 123 : sal_Int32 nRowCount = aRows.getLength();
102 123 : if( nColumnCount>1 && nRowCount>1 )
103 : {
104 : //we have complex categories
105 : //->split them in the direction of the first series
106 : //detect whether the first series is a row or a column
107 0 : bool bSeriesUsesColumns = true;
108 0 : ::std::vector< Reference< XDataSeries > > aSeries( ChartModelHelper::getDataSeries( xChartModel ) );
109 0 : if( !aSeries.empty() )
110 : {
111 0 : uno::Reference< data::XDataSource > xSeriesSource( aSeries.front(), uno::UNO_QUERY );
112 0 : ::rtl::OUString aStringDummy;
113 : bool bDummy;
114 0 : uno::Sequence< sal_Int32 > aSeqDummy;
115 0 : DataSourceHelper::readArguments( xDataProvider->detectArguments( xSeriesSource),
116 0 : aStringDummy, aSeqDummy, bSeriesUsesColumns, bDummy, bDummy );
117 : }
118 0 : if( bSeriesUsesColumns )
119 0 : m_aSplitCategoriesList=aColumns;
120 : else
121 0 : m_aSplitCategoriesList=aRows;
122 123 : }
123 123 : }
124 123 : }
125 : }
126 123 : if( !m_aSplitCategoriesList.getLength() )
127 : {
128 123 : m_aSplitCategoriesList.realloc(1);
129 123 : m_aSplitCategoriesList[0]=m_xOriginalCategories;
130 123 : }
131 : }
132 : }
133 0 : catch( const uno::Exception & ex )
134 : {
135 : ASSERT_EXCEPTION( ex );
136 : }
137 123 : }
138 :
139 164 : ExplicitCategoriesProvider::~ExplicitCategoriesProvider()
140 : {
141 164 : }
142 :
143 0 : Reference< chart2::data::XDataSequence > ExplicitCategoriesProvider::getOriginalCategories()
144 : {
145 0 : if( m_xOriginalCategories.is() )
146 0 : return m_xOriginalCategories->getValues();
147 0 : return 0;
148 : }
149 :
150 0 : const Sequence< Reference< data::XLabeledDataSequence> >& ExplicitCategoriesProvider::getSplitCategoriesList()
151 : {
152 0 : return m_aSplitCategoriesList;
153 : }
154 :
155 205 : bool ExplicitCategoriesProvider::hasComplexCategories() const
156 : {
157 205 : return m_aSplitCategoriesList.getLength() > 1;
158 : }
159 :
160 0 : sal_Int32 ExplicitCategoriesProvider::getCategoryLevelCount() const
161 : {
162 0 : sal_Int32 nCount = m_aSplitCategoriesList.getLength();
163 0 : if(!nCount)
164 0 : nCount = 1;
165 0 : return nCount;
166 : }
167 :
168 0 : std::vector<sal_Int32> lcl_getLimitingBorders( const std::vector< ComplexCategory >& rComplexCategories )
169 : {
170 0 : std::vector<sal_Int32> aLimitingBorders;
171 0 : std::vector< ComplexCategory >::const_iterator aIt( rComplexCategories.begin() );
172 0 : std::vector< ComplexCategory >::const_iterator aEnd( rComplexCategories.end() );
173 0 : sal_Int32 nBorderIndex = 0; /*border below the index*/
174 0 : for( ; aIt != aEnd; ++aIt )
175 : {
176 0 : ComplexCategory aComplexCategory(*aIt);
177 0 : nBorderIndex += aComplexCategory.Count;
178 0 : aLimitingBorders.push_back(nBorderIndex);
179 0 : }
180 0 : return aLimitingBorders;
181 : }
182 :
183 41 : void ExplicitCategoriesProvider::convertCategoryAnysToText( uno::Sequence< rtl::OUString >& rOutTexts, const uno::Sequence< uno::Any >& rInAnys, Reference< frame::XModel > xChartModel )
184 : {
185 41 : sal_Int32 nCount = rInAnys.getLength();
186 41 : if(!nCount)
187 41 : return;
188 41 : rOutTexts.realloc(nCount);
189 41 : Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( xChartModel, uno::UNO_QUERY );
190 41 : Reference< util::XNumberFormats > xNumberFormats;
191 41 : if( xNumberFormatsSupplier.is() )
192 41 : xNumberFormats = Reference< util::XNumberFormats >( xNumberFormatsSupplier->getNumberFormats() );
193 :
194 41 : sal_Int32 nAxisNumberFormat = 0;
195 41 : Reference< XCoordinateSystem > xCooSysModel( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
196 41 : if( xCooSysModel.is() )
197 : {
198 41 : Reference< chart2::XAxis > xAxis( xCooSysModel->getAxisByDimension(0,0) );
199 : nAxisNumberFormat = AxisHelper::getExplicitNumberFormatKeyForAxis(
200 41 : xAxis, xCooSysModel, xNumberFormatsSupplier, false );
201 : }
202 :
203 : sal_Int32 nLabelColor;
204 41 : bool bColorChanged = false;
205 :
206 41 : NumberFormatterWrapper aNumberFormatterWrapper( xNumberFormatsSupplier );
207 :
208 205 : for(sal_Int32 nN=0;nN<nCount;nN++)
209 : {
210 164 : rtl::OUString aText;
211 164 : uno::Any aAny = rInAnys[nN];
212 164 : if( aAny.hasValue() )
213 : {
214 164 : double fDouble = 0;
215 164 : if( aAny>>=fDouble )
216 : {
217 0 : if( !::rtl::math::isNan(fDouble) )
218 : aText = aNumberFormatterWrapper.getFormattedString(
219 0 : nAxisNumberFormat, fDouble, nLabelColor, bColorChanged );
220 : }
221 : else
222 : {
223 164 : aAny>>=aText;
224 : }
225 : }
226 164 : rOutTexts[nN] = aText;
227 205 : }
228 : }
229 :
230 0 : SplitCategoriesProvider::~SplitCategoriesProvider()
231 : {
232 0 : }
233 :
234 : class SplitCategoriesProvider_ForLabeledDataSequences : public SplitCategoriesProvider
235 : {
236 : public:
237 :
238 0 : explicit SplitCategoriesProvider_ForLabeledDataSequences(
239 : const ::com::sun::star::uno::Sequence<
240 : ::com::sun::star::uno::Reference<
241 : ::com::sun::star::chart2::data::XLabeledDataSequence> >& rSplitCategoriesList
242 : , const Reference< frame::XModel >& xChartModel )
243 : : m_rSplitCategoriesList( rSplitCategoriesList )
244 0 : , m_xChartModel( xChartModel )
245 0 : {}
246 0 : virtual ~SplitCategoriesProvider_ForLabeledDataSequences()
247 0 : {}
248 :
249 : virtual sal_Int32 getLevelCount() const;
250 : virtual uno::Sequence< rtl::OUString > getStringsForLevel( sal_Int32 nIndex ) const;
251 :
252 : private:
253 : const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference<
254 : ::com::sun::star::chart2::data::XLabeledDataSequence> >& m_rSplitCategoriesList;
255 :
256 : Reference< frame::XModel > m_xChartModel;
257 : };
258 :
259 0 : sal_Int32 SplitCategoriesProvider_ForLabeledDataSequences::getLevelCount() const
260 : {
261 0 : return m_rSplitCategoriesList.getLength();
262 : }
263 0 : uno::Sequence< rtl::OUString > SplitCategoriesProvider_ForLabeledDataSequences::getStringsForLevel( sal_Int32 nLevel ) const
264 : {
265 0 : uno::Sequence< rtl::OUString > aRet;
266 0 : Reference< data::XLabeledDataSequence > xLabeledDataSequence( m_rSplitCategoriesList[nLevel] );
267 0 : if( xLabeledDataSequence.is() )
268 : {
269 0 : uno::Reference< data::XDataSequence > xDataSequence( xLabeledDataSequence->getValues() );
270 0 : if( xDataSequence.is() )
271 0 : ExplicitCategoriesProvider::convertCategoryAnysToText( aRet, xDataSequence->getData(), m_xChartModel );
272 : }
273 0 : return aRet;
274 : }
275 :
276 0 : std::vector< ComplexCategory > lcl_DataSequenceToComplexCategoryVector(
277 : const uno::Sequence< rtl::OUString >& rStrings
278 : , const std::vector<sal_Int32>& rLimitingBorders, bool bCreateSingleCategories )
279 : {
280 0 : std::vector< ComplexCategory > aResult;
281 :
282 0 : sal_Int32 nMaxCount = rStrings.getLength();
283 0 : OUString aPrevious;
284 0 : sal_Int32 nCurrentCount=0;
285 0 : for( sal_Int32 nN=0; nN<nMaxCount; nN++ )
286 : {
287 0 : const OUString& aCurrent = rStrings[nN];
288 0 : if( bCreateSingleCategories || ::std::find( rLimitingBorders.begin(), rLimitingBorders.end(), nN ) != rLimitingBorders.end() )
289 : {
290 0 : aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
291 0 : nCurrentCount=1;
292 0 : aPrevious = aCurrent;
293 : }
294 : else
295 : {
296 : // Empty value is interpreted as a continuation of the previous
297 : // category. Note that having the same value as the previous one
298 : // does not equate to a continuation of the category.
299 :
300 0 : if (aCurrent.isEmpty())
301 0 : ++nCurrentCount;
302 : else
303 : {
304 0 : aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
305 0 : nCurrentCount=1;
306 0 : aPrevious = aCurrent;
307 : }
308 : }
309 : }
310 0 : if( nCurrentCount )
311 0 : aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
312 :
313 0 : return aResult;
314 : }
315 :
316 0 : sal_Int32 lcl_getCategoryCount( std::vector< ComplexCategory >& rComplexCategories )
317 : {
318 0 : sal_Int32 nCount = 0;
319 0 : std::vector< ComplexCategory >::const_iterator aIt( rComplexCategories.begin() );
320 0 : std::vector< ComplexCategory >::const_iterator aEnd( rComplexCategories.end() );
321 0 : for( ; aIt != aEnd; ++aIt )
322 0 : nCount+=aIt->Count;
323 0 : return nCount;
324 : }
325 :
326 0 : Sequence< OUString > lcl_getExplicitSimpleCategories(
327 : const SplitCategoriesProvider& rSplitCategoriesProvider,
328 : ::std::vector< ::std::vector< ComplexCategory > >& rComplexCats )
329 : {
330 0 : Sequence< OUString > aRet;
331 :
332 0 : rComplexCats.clear();
333 0 : sal_Int32 nLCount = rSplitCategoriesProvider.getLevelCount();
334 0 : for( sal_Int32 nL = 0; nL < nLCount; nL++ )
335 : {
336 0 : std::vector<sal_Int32> aLimitingBorders;
337 0 : if(nL>0)
338 0 : aLimitingBorders = lcl_getLimitingBorders( rComplexCats.back() );
339 : rComplexCats.push_back( lcl_DataSequenceToComplexCategoryVector(
340 0 : rSplitCategoriesProvider.getStringsForLevel(nL), aLimitingBorders, nL==(nLCount-1) ) );
341 0 : }
342 :
343 0 : std::vector< std::vector< ComplexCategory > >::iterator aOuterIt( rComplexCats.begin() );
344 0 : std::vector< std::vector< ComplexCategory > >::const_iterator aOuterEnd( rComplexCats.end() );
345 :
346 : //ensure that the category count is the same on each level
347 0 : sal_Int32 nMaxCategoryCount = 0;
348 : {
349 0 : for( aOuterIt=rComplexCats.begin(); aOuterIt != aOuterEnd; ++aOuterIt )
350 : {
351 0 : sal_Int32 nCurrentCount = lcl_getCategoryCount( *aOuterIt );
352 0 : nMaxCategoryCount = std::max( nCurrentCount, nMaxCategoryCount );
353 : }
354 0 : for( aOuterIt=rComplexCats.begin(); aOuterIt != aOuterEnd; ++aOuterIt )
355 : {
356 0 : sal_Int32 nCurrentCount = lcl_getCategoryCount( *aOuterIt );
357 0 : if( nCurrentCount< nMaxCategoryCount )
358 : {
359 0 : ComplexCategory& rComplexCategory = aOuterIt->back();
360 0 : rComplexCategory.Count += (nMaxCategoryCount-nCurrentCount);
361 : }
362 : }
363 : }
364 :
365 : //create a list with an element for every index
366 0 : std::vector< std::vector< ComplexCategory > > aComplexCatsPerIndex;
367 0 : for( aOuterIt=rComplexCats.begin() ; aOuterIt != aOuterEnd; ++aOuterIt )
368 : {
369 0 : std::vector< ComplexCategory > aSingleLevel;
370 0 : std::vector< ComplexCategory >::iterator aIt( aOuterIt->begin() );
371 0 : std::vector< ComplexCategory >::const_iterator aEnd( aOuterIt->end() );
372 0 : for( ; aIt != aEnd; ++aIt )
373 : {
374 0 : ComplexCategory aComplexCategory( *aIt );
375 0 : sal_Int32 nCount = aComplexCategory.Count;
376 0 : while( nCount-- )
377 0 : aSingleLevel.push_back(aComplexCategory);
378 0 : }
379 0 : aComplexCatsPerIndex.push_back( aSingleLevel );
380 0 : }
381 :
382 0 : if(nMaxCategoryCount)
383 : {
384 0 : aRet.realloc(nMaxCategoryCount);
385 0 : aOuterEnd = aComplexCatsPerIndex.end();
386 0 : OUString aSpace(C2U(" "));
387 0 : for(sal_Int32 nN=0; nN<nMaxCategoryCount; nN++)
388 : {
389 0 : OUString aText;
390 0 : for( aOuterIt=aComplexCatsPerIndex.begin() ; aOuterIt != aOuterEnd; ++aOuterIt )
391 : {
392 0 : OUString aAddText = (*aOuterIt)[nN].Text;
393 0 : if( !aAddText.isEmpty() )
394 : {
395 0 : if(!aText.isEmpty())
396 0 : aText += aSpace;
397 0 : aText += aAddText;
398 : }
399 0 : }
400 0 : aRet[nN]=aText;
401 0 : }
402 : }
403 0 : return aRet;
404 : }
405 :
406 0 : Sequence< OUString > ExplicitCategoriesProvider::getExplicitSimpleCategories(
407 : const SplitCategoriesProvider& rSplitCategoriesProvider )
408 : {
409 0 : vector< vector< ComplexCategory > > aComplexCats;
410 0 : return lcl_getExplicitSimpleCategories( rSplitCategoriesProvider, aComplexCats );
411 : }
412 :
413 : struct DatePlusIndexComparator
414 : {
415 738 : inline bool operator() ( const DatePlusIndex& aFirst,
416 : const DatePlusIndex& aSecond ) const
417 : {
418 738 : return ( aFirst.fValue < aSecond.fValue );
419 : }
420 : };
421 :
422 123 : bool lcl_fillDateCategories( const uno::Reference< data::XDataSequence >& xDataSequence, std::vector< DatePlusIndex >& rDateCategories, bool bIsAutoDate, Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier )
423 : {
424 123 : bool bOnlyDatesFound = true;
425 123 : bool bAnyDataFound = false;
426 :
427 123 : if( xDataSequence.is() )
428 : {
429 123 : uno::Sequence< uno::Any > aValues = xDataSequence->getData();
430 123 : sal_Int32 nCount = aValues.getLength();
431 123 : rDateCategories.reserve(nCount);
432 123 : Reference< util::XNumberFormats > xNumberFormats;
433 123 : if( xNumberFormatsSupplier.is() )
434 123 : xNumberFormats = Reference< util::XNumberFormats >( xNumberFormatsSupplier->getNumberFormats() );
435 :
436 123 : bool bOwnData = false;
437 123 : bool bOwnDataAnddAxisHasAnyFormat = false;
438 123 : bool bOwnDataAnddAxisHasDateFormat = false;
439 123 : Reference< chart2::XChartDocument > xChartDoc( xNumberFormatsSupplier, uno::UNO_QUERY );
440 123 : Reference< XCoordinateSystem > xCooSysModel( ChartModelHelper::getFirstCoordinateSystem( Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ) ) );
441 123 : if( xChartDoc.is() && xCooSysModel.is() )
442 : {
443 123 : if( xChartDoc->hasInternalDataProvider() )
444 : {
445 123 : bOwnData = true;
446 123 : Reference< beans::XPropertySet > xAxisProps( xCooSysModel->getAxisByDimension(0,0), uno::UNO_QUERY );
447 123 : sal_Int32 nAxisNumberFormat = 0;
448 123 : if( xAxisProps.is() && (xAxisProps->getPropertyValue( C2U("NumberFormat") ) >>= nAxisNumberFormat) )
449 : {
450 0 : bOwnDataAnddAxisHasAnyFormat = true;
451 0 : bOwnDataAnddAxisHasDateFormat = DiagramHelper::isDateNumberFormat( nAxisNumberFormat, xNumberFormats );
452 123 : }
453 : }
454 : }
455 :
456 615 : for(sal_Int32 nN=0;nN<nCount;nN++)
457 : {
458 492 : bool bIsDate = false;
459 492 : if( bIsAutoDate )
460 : {
461 492 : if( bOwnData )
462 492 : bIsDate = bOwnDataAnddAxisHasAnyFormat ? bOwnDataAnddAxisHasDateFormat : true;
463 : else
464 0 : bIsDate = DiagramHelper::isDateNumberFormat( xDataSequence->getNumberFormatKeyByIndex( nN ), xNumberFormats );
465 : }
466 : else
467 0 : bIsDate = true;
468 :
469 492 : bool bContainsEmptyString = false;
470 492 : bool bContainsNan = false;
471 492 : uno::Any aAny = aValues[nN];
472 492 : if( aAny.hasValue() )
473 : {
474 492 : OUString aTest;
475 492 : double fTest = 0;
476 492 : if( (aAny>>=aTest) && aTest.isEmpty() ) //empty String
477 0 : bContainsEmptyString = true;
478 492 : else if( (aAny>>=fTest) && ::rtl::math::isNan(fTest) )
479 0 : bContainsNan = true;
480 :
481 492 : if( !bContainsEmptyString && !bContainsNan )
482 492 : bAnyDataFound = true;
483 : }
484 492 : DatePlusIndex aDatePlusIndex( 1.0, nN );
485 492 : if( bIsDate && (aAny >>= aDatePlusIndex.fValue) )
486 0 : rDateCategories.push_back( aDatePlusIndex );
487 : else
488 : {
489 492 : if( aAny.hasValue() && !bContainsEmptyString )//empty string does not count as non date value!
490 492 : bOnlyDatesFound=false;
491 492 : ::rtl::math::setNan( &aDatePlusIndex.fValue );
492 492 : rDateCategories.push_back( aDatePlusIndex );
493 : }
494 492 : }
495 123 : ::std::sort( rDateCategories.begin(), rDateCategories.end(), DatePlusIndexComparator() );
496 : }
497 :
498 123 : return bAnyDataFound && bOnlyDatesFound;
499 : }
500 :
501 492 : void ExplicitCategoriesProvider::init()
502 : {
503 492 : if( m_bDirty )
504 : {
505 123 : m_aComplexCats.clear();//not one per index
506 123 : m_aDateCategories.clear();
507 :
508 123 : if( m_xOriginalCategories.is() )
509 : {
510 123 : if( !hasComplexCategories() )
511 : {
512 123 : if(m_bIsDateAxis)
513 : {
514 123 : if( ChartTypeHelper::isSupportingDateAxis( AxisHelper::getChartTypeByIndex( m_xCooSysModel, 0 ), 2, 0 ) )
515 123 : m_bIsDateAxis = lcl_fillDateCategories( m_xOriginalCategories->getValues(), m_aDateCategories, m_bIsAutoDate, Reference< util::XNumberFormatsSupplier >( m_xChartModel.get(), uno::UNO_QUERY ) );
516 : else
517 0 : m_bIsDateAxis = false;
518 : }
519 : }
520 : else
521 : {
522 0 : m_bIsDateAxis = false;
523 : }
524 : }
525 : else
526 0 : m_bIsDateAxis=false;
527 123 : m_bDirty = false;
528 : }
529 492 : }
530 :
531 :
532 41 : Sequence< ::rtl::OUString > ExplicitCategoriesProvider::getSimpleCategories()
533 : {
534 41 : if( !m_bIsExplicitCategoriesInited )
535 : {
536 41 : init();
537 41 : m_aExplicitCategories.realloc(0);
538 41 : if( m_xOriginalCategories.is() )
539 : {
540 41 : if( !hasComplexCategories() )
541 : {
542 41 : uno::Reference< data::XDataSequence > xDataSequence( m_xOriginalCategories->getValues() );
543 41 : if( xDataSequence.is() )
544 41 : ExplicitCategoriesProvider::convertCategoryAnysToText( m_aExplicitCategories, xDataSequence->getData(), m_xChartModel );
545 : }
546 : else
547 : {
548 : m_aExplicitCategories = lcl_getExplicitSimpleCategories(
549 0 : SplitCategoriesProvider_ForLabeledDataSequences( m_aSplitCategoriesList, m_xChartModel ), m_aComplexCats );
550 : }
551 : }
552 41 : if(!m_aExplicitCategories.getLength())
553 0 : m_aExplicitCategories = DiagramHelper::generateAutomaticCategoriesFromCooSys( m_xCooSysModel );
554 41 : m_bIsExplicitCategoriesInited = true;
555 : }
556 41 : return m_aExplicitCategories;
557 : }
558 :
559 0 : const std::vector<ComplexCategory>* ExplicitCategoriesProvider::getCategoriesByLevel( sal_Int32 nLevel )
560 : {
561 0 : init();
562 0 : sal_Int32 nMaxIndex = m_aComplexCats.size()-1;
563 0 : if (nLevel >= 0 && nLevel <= nMaxIndex)
564 0 : return &m_aComplexCats[nMaxIndex-nLevel];
565 0 : return NULL;
566 : }
567 :
568 0 : OUString ExplicitCategoriesProvider::getCategoryByIndex(
569 : const Reference< XCoordinateSystem >& xCooSysModel
570 : , const uno::Reference< frame::XModel >& xChartModel
571 : , sal_Int32 nIndex )
572 : {
573 0 : if( xCooSysModel.is())
574 : {
575 0 : ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSysModel, xChartModel );
576 0 : Sequence< OUString > aCategories( aExplicitCategoriesProvider.getSimpleCategories());
577 0 : if( nIndex < aCategories.getLength())
578 0 : return aCategories[ nIndex ];
579 : }
580 0 : return OUString();
581 : }
582 :
583 451 : bool ExplicitCategoriesProvider::isDateAxis()
584 : {
585 451 : init();
586 451 : return m_bIsDateAxis;
587 : }
588 :
589 0 : const std::vector< DatePlusIndex >& ExplicitCategoriesProvider::getDateCategories()
590 : {
591 0 : init();
592 0 : return m_aDateCategories;
593 : }
594 :
595 : //.............................................................................
596 : } //namespace chart
597 : //.............................................................................
598 :
599 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
