chart2/source/tools/DataSourceHelper.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 <DataSourceHelper.hxx>
  21 #include <ChartModel.hxx>
  22 #include <ChartModelHelper.hxx>
  23 #include <ChartTypeManager.hxx>
  24 #include <Diagram.hxx>
  25 #include <DataSeries.hxx>
  26 #include <DataSeriesHelper.hxx>
  27 #include <DataSource.hxx>
  28 #include <ControllerLockGuard.hxx>
  29 #include <CachedDataSequence.hxx>
  30 #include <LabeledDataSequence.hxx>
  31 #include <unonames.hxx>
  32
  33 #include <com/sun/star/chart2/data/XDataSource.hpp>
  34 #include <com/sun/star/chart2/data/XLabeledDataSequence.hpp>
  35
  36 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  37 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  38 #include <comphelper/diagnose_ex.hxx>
  39
  40 namespace chart
  41 {
  42 using namespace ::com::sun::star;
  43 using namespace ::com::sun::star::chart2;
  44 using ::com::sun::star::uno::Reference;
  45 using ::com::sun::star::uno::Sequence;
  46
  47 namespace
  48 {
  49 void lcl_addRanges( std::vector< OUString > & rOutResult,
  50                     const uno::Reference< data::XLabeledDataSequence > & xLabeledSeq )
  51 {
  52     if( ! xLabeledSeq.is())
  53         return;
  54     uno::Reference< data::XDataSequence > xSeq( xLabeledSeq->getLabel());
  55     if( xSeq.is())
  56         rOutResult.push_back( xSeq->getSourceRangeRepresentation());
  57     xSeq.set( xLabeledSeq->getValues());
  58     if( xSeq.is())
  59         rOutResult.push_back( xSeq->getSourceRangeRepresentation());
  60 }
  61
  62 void lcl_addDataSourceRanges(
  63     std::vector< OUString > & rOutResult,
  64     const uno::Reference< data::XDataSource > & xDataSource )
  65 {
  66     if( xDataSource.is() )
  67     {
  68         const auto aDataSequences(xDataSource->getDataSequences());
  69         for (const auto& rDataSequence : aDataSequences)
  70             lcl_addRanges(rOutResult, rDataSequence);
  71     }
  72 }
  73
  74 void lcl_addErrorBarRanges(
  75     std::vector< OUString > & rOutResult,
  76     const rtl::Reference< DataSeries > & xDataSeries )
  77 {
  78     if( !xDataSeries.is())
  79         return;
  80
  81     try
  82     {
  83         uno::Reference< beans::XPropertySet > xErrorBarProp;
  84         if( ( xDataSeries->getPropertyValue( CHART_UNONAME_ERRORBAR_Y) >>= xErrorBarProp ) &&
  85             xErrorBarProp.is())
  86         {
  87             sal_Int32 eStyle = css::chart::ErrorBarStyle::NONE;
  88             if( ( xErrorBarProp->getPropertyValue( u"ErrorBarStyle"_ustr) >>= eStyle ) &&
  89                 eStyle == css::chart::ErrorBarStyle::FROM_DATA )
  90             {
  91                 uno::Reference< data::XDataSource > xErrorBarDataSource( xErrorBarProp, uno::UNO_QUERY );
  92                 if( xErrorBarDataSource.is() )
  93                     lcl_addDataSourceRanges( rOutResult, xErrorBarDataSource );
  94             }
  95         }
  96
  97         if( ( xDataSeries->getPropertyValue(CHART_UNONAME_ERRORBAR_X) >>= xErrorBarProp ) && xErrorBarProp.is())
  98         {
  99             sal_Int32 eStyle = css::chart::ErrorBarStyle::NONE;
 100             if( ( xErrorBarProp->getPropertyValue(u"ErrorBarStyle"_ustr) >>= eStyle ) &&
 101                 eStyle == css::chart::ErrorBarStyle::FROM_DATA )
 102             {
 103                 uno::Reference< data::XDataSource > xErrorBarDataSource( xErrorBarProp, uno::UNO_QUERY );
 104                 if( xErrorBarDataSource.is() )
 105                     lcl_addDataSourceRanges( rOutResult, xErrorBarDataSource );
 106             }
 107         }
 108     }
 109     catch( const uno::Exception & )
 110     {
 111         DBG_UNHANDLED_EXCEPTION("chart2");
 112     }
 113 }
 114
 115 } // anonymous namespace
 116
 117 Reference< chart2::data::XDataSequence > DataSourceHelper::createCachedDataSequence()
 118 {
 119     return new ::chart::CachedDataSequence();
 120 }
 121
 122 Reference< chart2::data::XDataSequence > DataSourceHelper::createCachedDataSequence( const OUString& rSingleText )
 123 {
 124     return new ::chart::CachedDataSequence( rSingleText );
 125 }
 126
 127 rtl::Reference< LabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
 128         const Reference< chart2::data::XDataSequence >& xValues ,
 129         const Reference< chart2::data::XDataSequence >& xLabels )
 130 {
 131     return new ::chart::LabeledDataSequence( xValues, xLabels );
 132 }
 133
 134 rtl::Reference< LabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
 135         const Reference< chart2::data::XDataSequence >& xValues )
 136 {
 137     return new ::chart::LabeledDataSequence( xValues );
 138 }
 139
 140 rtl::Reference< LabeledDataSequence > DataSourceHelper::createLabeledDataSequence()
 141 {
 142     return new ::chart::LabeledDataSequence;
 143 }
 144
 145 uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
 146                                             bool bUseColumns, bool bFirstCellAsLabel, bool bHasCategories )
 147 {
 148     css::chart::ChartDataRowSource eRowSource = css::chart::ChartDataRowSource_ROWS;
 149     if( bUseColumns )
 150         eRowSource = css::chart::ChartDataRowSource_COLUMNS;
 151
 152     return
 153     {
 154         { u"DataRowSource"_ustr, -1, uno::Any( eRowSource), beans::PropertyState_DIRECT_VALUE },
 155         { u"FirstCellAsLabel"_ustr, -1, uno::Any( bFirstCellAsLabel ), beans::PropertyState_DIRECT_VALUE },
 156         { u"HasCategories"_ustr, -1, uno::Any( bHasCategories ), beans::PropertyState_DIRECT_VALUE }
 157     };
 158 }
 159
 160 uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
 161                                             const OUString & rRangeRepresentation,
 162                                             const uno::Sequence< sal_Int32 >& rSequenceMapping,
 163                                             bool bUseColumns, bool bFirstCellAsLabel, bool bHasCategories )
 164 {
 165     uno::Sequence< beans::PropertyValue > aArguments( createArguments( bUseColumns, bFirstCellAsLabel, bHasCategories ));
 166     aArguments.realloc( aArguments.getLength() + 1 );
 167     aArguments.getArray()[aArguments.getLength() - 1] =
 168         beans::PropertyValue( u"CellRangeRepresentation"_ustr
 169                               , -1, uno::Any( rRangeRepresentation )
 170                               , beans::PropertyState_DIRECT_VALUE );
 171     if( rSequenceMapping.hasElements() )
 172     {
 173         aArguments.realloc( aArguments.getLength() + 1 );
 174         aArguments.getArray()[aArguments.getLength() - 1] =
 175             beans::PropertyValue( u"SequenceMapping"_ustr
 176                                 , -1, uno::Any( rSequenceMapping )
 177                                 , beans::PropertyState_DIRECT_VALUE );
 178     }
 179     return aArguments;
 180 }
 181
 182 void DataSourceHelper::readArguments( const uno::Sequence< beans::PropertyValue >& rArguments
 183                                      , OUString & rRangeRepresentation, uno::Sequence< sal_Int32 >& rSequenceMapping
 184             , bool& bUseColumns, bool& bFirstCellAsLabel, bool& bHasCategories )
 185 {
 186     for(const beans::PropertyValue& rProperty : rArguments)
 187     {
 188         if ( rProperty.Name == "DataRowSource" )
 189         {
 190             css::chart::ChartDataRowSource eRowSource;
 191             if( rProperty.Value >>= eRowSource )
 192                 bUseColumns = (eRowSource==css::chart::ChartDataRowSource_COLUMNS);
 193         }
 194         else if ( rProperty.Name == "FirstCellAsLabel" )
 195         {
 196             rProperty.Value >>= bFirstCellAsLabel;
 197         }
 198         else if ( rProperty.Name == "HasCategories" )
 199         {
 200             rProperty.Value >>= bHasCategories;
 201         }
 202         else if ( rProperty.Name == "CellRangeRepresentation" )
 203         {
 204             rProperty.Value >>= rRangeRepresentation;
 205         }
 206         else if ( rProperty.Name == "SequenceMapping" )
 207         {
 208             rProperty.Value >>= rSequenceMapping;
 209         }
 210     }
 211 }
 212
 213 rtl::Reference< DataSource > DataSourceHelper::pressUsedDataIntoRectangularFormat(
 214         const rtl::Reference< ChartModel >& xChartDoc )
 215 {
 216     std::vector< Reference< chart2::data::XLabeledDataSequence > > aResultVector;
 217
 218     //categories are always the first sequence
 219     rtl::Reference< Diagram > xDiagram( xChartDoc->getFirstChartDiagram());
 220
 221     Reference< chart2::data::XLabeledDataSequence > xCategories;
 222     if (xDiagram)
 223         xCategories = xDiagram->getCategories();
 224     if( xCategories.is() )
 225         aResultVector.push_back( xCategories );
 226
 227     std::vector< rtl::Reference< DataSeries > > aSeriesVector;
 228     if (xDiagram)
 229         aSeriesVector = xDiagram->getDataSeries();
 230     uno::Reference< chart2::data::XDataSource > xSeriesSource =
 231         DataSeriesHelper::getDataSource( aSeriesVector );
 232     const Sequence< Reference< chart2::data::XLabeledDataSequence > > aDataSequences( xSeriesSource->getDataSequences() );
 233
 234     //the first x-values is always the next sequence //todo ... other x-values get lost for old format
 235     Reference< chart2::data::XLabeledDataSequence > xXValues(
 236         DataSeriesHelper::getDataSequenceByRole( xSeriesSource, u"values-x"_ustr ) );
 237     if( xXValues.is() )
 238         aResultVector.push_back( xXValues );
 239
 240     //add all other sequences now without x-values
 241     for(  Reference< chart2::data::XLabeledDataSequence > const & labeledData : aDataSequences )
 242     {
 243         OUString aRole = DataSeriesHelper::getRole(labeledData);
 244         if( aRole != "values-x" )
 245             aResultVector.push_back( labeledData );
 246     }
 247
 248     return new DataSource( aResultVector );
 249 }
 250
 251 uno::Sequence< OUString > DataSourceHelper::getUsedDataRanges(
 252     const rtl::Reference< Diagram > & xDiagram )
 253 {
 254     std::vector< OUString > aResult;
 255
 256     if( xDiagram.is())
 257     {
 258         uno::Reference< data::XLabeledDataSequence > xCategories( xDiagram->getCategories() );
 259         if( xCategories.is() )
 260             lcl_addRanges( aResult, xCategories );
 261
 262         std::vector< rtl::Reference< DataSeries > > aSeriesVector( xDiagram->getDataSeries() );
 263         for (auto const& series : aSeriesVector)
 264         {
 265             lcl_addDataSourceRanges( aResult, series );
 266             lcl_addErrorBarRanges( aResult, series );
 267         }
 268     }
 269
 270     return comphelper::containerToSequence( aResult );
 271 }
 272
 273 uno::Sequence< OUString > DataSourceHelper::getUsedDataRanges( const rtl::Reference<::chart::ChartModel> & xChartModel )
 274 {
 275     rtl::Reference< Diagram > xDiagram( xChartModel->getFirstChartDiagram() );
 276     return getUsedDataRanges( xDiagram );
 277 }
 278
 279 rtl::Reference< DataSource > DataSourceHelper::getUsedData(
 280     ChartModel& rModel )
 281 {
 282     std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > aResult;
 283
 284     rtl::Reference< Diagram > xDiagram =  rModel.getFirstChartDiagram();
 285     uno::Reference< chart2::data::XLabeledDataSequence > xCategories( xDiagram->getCategories() );
 286     if( xCategories.is() )
 287         aResult.push_back( xCategories );
 288
 289     std::vector< rtl::Reference< DataSeries > > aSeriesVector = ChartModelHelper::getDataSeries( &rModel );
 290     for (auto const& series : aSeriesVector)
 291     {
 292         const std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > & aDataSequences( series->getDataSequences2() );
 293         aResult.insert( aResult.end(), aDataSequences.begin(), aDataSequences.end() );
 294     }
 295
 296     return new DataSource( aResult );
 297 }
 298
 299 bool DataSourceHelper::detectRangeSegmentation(
 300     const rtl::Reference<::chart::ChartModel>& xChartModel
 301     , OUString& rOutRangeString
 302     , css::uno::Sequence< sal_Int32 >& rSequenceMapping
 303     , bool& rOutUseColumns
 304     , bool& rOutFirstCellAsLabel
 305     , bool& rOutHasCategories )
 306 {
 307     bool bSomethingDetected = false;
 308
 309     if( !xChartModel.is() )
 310         return bSomethingDetected;
 311     uno::Reference< data::XDataProvider >  xDataProvider( xChartModel->getDataProvider() );
 312     if( !xDataProvider.is() )
 313         return bSomethingDetected;
 314
 315     try
 316     {
 317         DataSourceHelper::readArguments(
 318             xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartModel ) ),
 319             rOutRangeString, rSequenceMapping, rOutUseColumns, rOutFirstCellAsLabel, rOutHasCategories );
 320         bSomethingDetected = !rOutRangeString.isEmpty();
 321
 322         rtl::Reference<Diagram> xDiagram = xChartModel->getFirstChartDiagram();
 323         uno::Reference< chart2::data::XLabeledDataSequence > xCategories;
 324         if (xDiagram)
 325             xCategories = xDiagram->getCategories();
 326         rOutHasCategories = xCategories.is();
 327     }
 328     catch( uno::Exception & )
 329     {
 330         DBG_UNHANDLED_EXCEPTION("chart2");
 331     }
 332     return bSomethingDetected;
 333 }
 334
 335 bool DataSourceHelper::allArgumentsForRectRangeDetected(
 336     const rtl::Reference<::chart::ChartModel>& xChartDocument )
 337 {
 338     bool bHasDataRowSource = false;
 339     bool bHasFirstCellAsLabel = false;
 340     bool bHasCellRangeRepresentation = false;
 341
 342     uno::Reference< data::XDataProvider > xDataProvider( xChartDocument->getDataProvider() );
 343     if( !xDataProvider.is() )
 344         return false;
 345
 346     try
 347     {
 348         const uno::Sequence< beans::PropertyValue > aArguments(
 349             xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartDocument )));
 350         for(const beans::PropertyValue& rProperty : aArguments)
 351         {
 352             if ( rProperty.Name == "DataRowSource" )
 353             {
 354                 bHasDataRowSource =
 355                     (rProperty.Value.hasValue() && rProperty.Value.isExtractableTo(
 356                         cppu::UnoType<css::chart::ChartDataRowSource>::get()));
 357             }
 358             else if ( rProperty.Name == "FirstCellAsLabel" )
 359             {
 360                 bHasFirstCellAsLabel =
 361                     (rProperty.Value.hasValue() && rProperty.Value.isExtractableTo(cppu::UnoType<bool>::get()));
 362             }
 363             else if ( rProperty.Name == "CellRangeRepresentation" )
 364             {
 365                 OUString aRange;
 366                 bHasCellRangeRepresentation =
 367                     (rProperty.Value.hasValue() && (rProperty.Value >>= aRange) && !aRange.isEmpty());
 368             }
 369         }
 370     }
 371     catch( const uno::Exception & )
 372     {
 373         DBG_UNHANDLED_EXCEPTION("chart2");
 374     }
 375
 376     return (bHasCellRangeRepresentation && bHasDataRowSource && bHasFirstCellAsLabel);
 377 }
 378
 379 void DataSourceHelper::setRangeSegmentation(
 380             const rtl::Reference<::chart::ChartModel>& xChartModel
 381             , const css::uno::Sequence< sal_Int32 >& rSequenceMapping
 382             , bool bUseColumns , bool bFirstCellAsLabel, bool bUseCategories )
 383 {
 384     uno::Reference< data::XDataProvider > xDataProvider( xChartModel->getDataProvider() );
 385     if( !xDataProvider.is() )
 386         return;
 387     rtl::Reference< Diagram > xDiagram( xChartModel->getFirstChartDiagram() );
 388     if( !xDiagram.is() )
 389         return;
 390     rtl::Reference< ::chart::ChartTypeManager > xChartTypeManager = xChartModel->getTypeManager();
 391     if( !xChartTypeManager.is() )
 392         return;
 393
 394     OUString aRangeString;
 395     bool bDummy;
 396     uno::Sequence< sal_Int32 > aDummy;
 397     readArguments( xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartModel )),
 398                    aRangeString, aDummy, bDummy, bDummy, bDummy );
 399
 400     uno::Sequence< beans::PropertyValue > aArguments(
 401         createArguments( aRangeString, rSequenceMapping, bUseColumns, bFirstCellAsLabel, bUseCategories ) );
 402
 403     uno::Reference< chart2::data::XDataSource > xDataSource( xDataProvider->createDataSource(
 404                                                                  aArguments ) );
 405     if( !xDataSource.is() )
 406         return;
 407
 408     ControllerLockGuardUNO aCtrlLockGuard( xChartModel );
 409     xDiagram->setDiagramData( xDataSource, aArguments );
 410 }
 411
 412 Sequence< OUString > DataSourceHelper::getRangesFromLabeledDataSequence(
 413     const Reference< data::XLabeledDataSequence > & xLSeq )
 414 {
 415     Sequence< OUString > aResult;
 416     if( xLSeq.is())
 417     {
 418         Reference< data::XDataSequence > xLabel( xLSeq->getLabel());
 419         Reference< data::XDataSequence > xValues( xLSeq->getValues());
 420
 421         if( xLabel.is())
 422         {
 423             if( xValues.is())
 424             {
 425                 aResult = { xLabel->getSourceRangeRepresentation(),
 426                             xValues->getSourceRangeRepresentation() };
 427             }
 428             else
 429             {
 430                 aResult = { xLabel->getSourceRangeRepresentation() };
 431             }
 432         }
 433         else if( xValues.is())
 434         {
 435             aResult = { xValues->getSourceRangeRepresentation() };
 436         }
 437     }
 438     return aResult;
 439 }
 440
 441 OUString DataSourceHelper::getRangeFromValues(
 442     const Reference< data::XLabeledDataSequence > & xLSeq )
 443 {
 444     OUString aResult;
 445     if( xLSeq.is() )
 446     {
 447         Reference< data::XDataSequence > xValues( xLSeq->getValues() );
 448         if( xValues.is() )
 449             aResult = xValues->getSourceRangeRepresentation();
 450     }
 451     return aResult;
 452 }
 453
 454 Sequence< OUString > DataSourceHelper::getRangesFromDataSource( const Reference< data::XDataSource > & xSource )
 455 {
 456     std::vector< OUString > aResult;
 457     if( xSource.is())
 458     {
 459         const Sequence< Reference< data::XLabeledDataSequence > > aLSeqSeq( xSource->getDataSequences());
 460         for( Reference< data::XLabeledDataSequence > const & labeledData : aLSeqSeq )
 461         {
 462             Reference< data::XDataSequence > xLabel( labeledData->getLabel());
 463             Reference< data::XDataSequence > xValues( labeledData->getValues());
 464
 465             if( xLabel.is())
 466                 aResult.push_back( xLabel->getSourceRangeRepresentation());
 467             if( xValues.is())
 468                 aResult.push_back( xValues->getSourceRangeRepresentation());
 469         }
 470     }
 471     return comphelper::containerToSequence( aResult );
 472 }
 473
 474 } //namespace chart
 475
 476 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */