chart2/source/tools/ExplicitCategoriesProvider.cxx

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