chart2/source/tools/ExplicitCategoriesProvider.cxx

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