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