chart2/source/tools/DataSourceHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: DataSourceHelper.cxx,v $
  10  * $Revision: 1.6.16.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33
  34 #include "DataSourceHelper.hxx"
  35 #include "macros.hxx"
  36 #include "ChartModelHelper.hxx"
  37 #include "DiagramHelper.hxx"
  38 #include "DataSeriesHelper.hxx"
  39 #include "DataSource.hxx"
  40 #include "ContainerHelper.hxx"
  41 #include "ControllerLockGuard.hxx"
  42 #include "PropertyHelper.hxx"
  43 #include "CachedDataSequence.hxx"
  44 #include "LabeledDataSequence.hxx"
  45
  46 #include <com/sun/star/chart2/XChartDocument.hpp>
  47 #include <com/sun/star/chart2/data/XDataSource.hpp>
  48 #include <com/sun/star/chart2/data/XLabeledDataSequence.hpp>
  49
  50 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  51 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  52
  53 //.............................................................................
  54 namespace chart
  55 {
  56 //.............................................................................
  57 using namespace ::com::sun::star;
  58 using namespace ::com::sun::star::chart2;
  59 using ::com::sun::star::uno::Reference;
  60 using ::com::sun::star::uno::Sequence;
  61 using ::rtl::OUString;
  62
  63 namespace
  64 {
  65 void lcl_addRanges( ::std::vector< ::rtl::OUString > & rOutResult,
  66                     const uno::Reference< data::XLabeledDataSequence > & xLabeledSeq )
  67 {
  68     if( ! xLabeledSeq.is())
  69         return;
  70     uno::Reference< data::XDataSequence > xSeq( xLabeledSeq->getLabel());
  71     if( xSeq.is())
  72         rOutResult.push_back( xSeq->getSourceRangeRepresentation());
  73     xSeq.set( xLabeledSeq->getValues());
  74     if( xSeq.is())
  75         rOutResult.push_back( xSeq->getSourceRangeRepresentation());
  76 }
  77
  78 void lcl_addDataSourceRanges(
  79     ::std::vector< ::rtl::OUString > & rOutResult,
  80     const uno::Reference< data::XDataSource > & xDataSource )
  81 {
  82     if( xDataSource.is() )
  83     {
  84         uno::Sequence< uno::Reference< data::XLabeledDataSequence > > aDataSequences( xDataSource->getDataSequences() );
  85         for( sal_Int32 i=0; i<aDataSequences.getLength(); ++i)
  86             lcl_addRanges( rOutResult, aDataSequences[i] );
  87     }
  88 }
  89
  90 void lcl_addErrorBarRanges(
  91     ::std::vector< ::rtl::OUString > & rOutResult,
  92     const uno::Reference< XDataSeries > & xDataSeries )
  93 {
  94     uno::Reference< beans::XPropertySet > xSeriesProp( xDataSeries, uno::UNO_QUERY );
  95     if( !xSeriesProp.is())
  96         return;
  97
  98     try
  99     {
 100         uno::Reference< beans::XPropertySet > xErrorBarProp;
 101         if( ( xSeriesProp->getPropertyValue( C2U("ErrorBarY")) >>= xErrorBarProp ) &&
 102             xErrorBarProp.is())
 103         {
 104             sal_Int32 eStyle = ::com::sun::star::chart::ErrorBarStyle::NONE;
 105             if( ( xErrorBarProp->getPropertyValue( C2U("ErrorBarStyle")) >>= eStyle ) &&
 106                 eStyle == ::com::sun::star::chart::ErrorBarStyle::FROM_DATA )
 107             {
 108                 uno::Reference< data::XDataSource > xErrorBarDataSource( xErrorBarProp, uno::UNO_QUERY );
 109                 if( xErrorBarDataSource.is() )
 110                     lcl_addDataSourceRanges( rOutResult, xErrorBarDataSource );
 111             }
 112         }
 113     }
 114     catch( const uno::Exception & ex )
 115     {
 116         ASSERT_EXCEPTION( ex );
 117     }
 118 }
 119
 120 } // anonymous namespace
 121
 122 Reference< chart2::data::XDataSource > DataSourceHelper::createDataSource(
 123         const Sequence< Reference< chart2::data::XLabeledDataSequence > >& rSequences )
 124 {
 125     return new DataSource(rSequences);
 126 }
 127
 128 Reference< chart2::data::XDataSequence > DataSourceHelper::createCachedDataSequence()
 129 {
 130     return new ::chart::CachedDataSequence();
 131 }
 132
 133 Reference< chart2::data::XDataSequence > DataSourceHelper::createCachedDataSequence( const ::rtl::OUString& rSingleText )
 134 {
 135     return new ::chart::CachedDataSequence( rSingleText );
 136 }
 137
 138 Reference< chart2::data::XLabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
 139         const Reference< chart2::data::XDataSequence >& xValues ,
 140         const Reference< chart2::data::XDataSequence >& xLabels )
 141 {
 142     return new ::chart::LabeledDataSequence( xValues, xLabels );
 143 }
 144
 145 Reference< chart2::data::XLabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
 146         const Reference< chart2::data::XDataSequence >& xValues )
 147 {
 148     return new ::chart::LabeledDataSequence( xValues );
 149 }
 150
 151 Reference< chart2::data::XLabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
 152         const Reference< uno::XComponentContext >& xContext )
 153 {
 154     return new ::chart::LabeledDataSequence( xContext );
 155 }
 156
 157 uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
 158                                             bool bUseColumns, bool bFirstCellAsLabel, bool bHasCategories )
 159 {
 160     ::com::sun::star::chart::ChartDataRowSource eRowSource = ::com::sun::star::chart::ChartDataRowSource_ROWS;
 161     if( bUseColumns )
 162         eRowSource = ::com::sun::star::chart::ChartDataRowSource_COLUMNS;
 163
 164     uno::Sequence< beans::PropertyValue > aArguments(3);
 165     aArguments[0] = beans::PropertyValue( C2U("DataRowSource")
 166         , -1, uno::makeAny( eRowSource )
 167         , beans::PropertyState_DIRECT_VALUE );
 168     aArguments[1] = beans::PropertyValue( C2U("FirstCellAsLabel")
 169         , -1, uno::makeAny( bFirstCellAsLabel )
 170         , beans::PropertyState_DIRECT_VALUE );
 171     aArguments[2] = beans::PropertyValue( C2U("HasCategories")
 172         , -1, uno::makeAny( bHasCategories )
 173         , beans::PropertyState_DIRECT_VALUE );
 174
 175     return aArguments;
 176 }
 177
 178 uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
 179                                             const ::rtl::OUString & rRangeRepresentation,
 180                                             const uno::Sequence< sal_Int32 >& rSequenceMapping,
 181                                             bool bUseColumns, bool bFirstCellAsLabel, bool bHasCategories )
 182 {
 183     uno::Sequence< beans::PropertyValue > aArguments( createArguments( bUseColumns, bFirstCellAsLabel, bHasCategories ));
 184     aArguments.realloc( aArguments.getLength() + 1 );
 185     aArguments[aArguments.getLength() - 1] =
 186         beans::PropertyValue( C2U("CellRangeRepresentation")
 187                               , -1, uno::makeAny( rRangeRepresentation )
 188                               , beans::PropertyState_DIRECT_VALUE );
 189     if( rSequenceMapping.getLength() )
 190     {
 191         aArguments.realloc( aArguments.getLength() + 1 );
 192         aArguments[aArguments.getLength() - 1] =
 193             beans::PropertyValue( C2U("SequenceMapping")
 194                                 , -1, uno::makeAny( rSequenceMapping )
 195                                 , beans::PropertyState_DIRECT_VALUE );
 196     }
 197     return aArguments;
 198 }
 199
 200 void DataSourceHelper::readArguments( const uno::Sequence< beans::PropertyValue >& rArguments
 201                                      , ::rtl::OUString & rRangeRepresentation, uno::Sequence< sal_Int32 >& rSequenceMapping
 202             , bool& bUseColumns, bool& bFirstCellAsLabel, bool& bHasCategories )
 203 {
 204     const beans::PropertyValue* pArguments = rArguments.getConstArray();
 205     for(sal_Int32 i=0; i<rArguments.getLength(); ++i, ++pArguments)
 206     {
 207         const beans::PropertyValue& aProperty = *pArguments;
 208         if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DataRowSource" ) ))
 209         {
 210             ::com::sun::star::chart::ChartDataRowSource eRowSource;
 211             if( aProperty.Value >>= eRowSource )
 212                 bUseColumns = (eRowSource==::com::sun::star::chart::ChartDataRowSource_COLUMNS);
 213         }
 214         else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FirstCellAsLabel" ) ))
 215         {
 216             aProperty.Value >>= bFirstCellAsLabel;
 217         }
 218         else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "HasCategories" ) ))
 219         {
 220             aProperty.Value >>= bHasCategories;
 221         }
 222         else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CellRangeRepresentation" ) ))
 223         {
 224             aProperty.Value >>= rRangeRepresentation;
 225         }
 226         else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "SequenceMapping" ) ))
 227         {
 228             aProperty.Value >>= rSequenceMapping;
 229         }
 230     }
 231 }
 232
 233 uno::Reference< chart2::data::XDataSource > DataSourceHelper::pressUsedDataIntoRectangularFormat(
 234         const uno::Reference< chart2::XChartDocument >& xChartDoc, bool bWithCategories )
 235 {
 236     ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aResultVector;
 237
 238     //categories are always the first sequence
 239     Reference< chart2::XDiagram > xDiagram( xChartDoc->getFirstDiagram());
 240
 241     if( bWithCategories )
 242     {
 243         Reference< chart2::data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
 244         if( xCategories.is() )
 245             aResultVector.push_back( xCategories );
 246     }
 247
 248     ::std::vector< Reference< chart2::XDataSeries > > xSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
 249     uno::Reference< chart2::data::XDataSource > xSeriesSource(
 250         DataSeriesHelper::getDataSource( ContainerHelper::ContainerToSequence(xSeriesVector) ) );
 251     Sequence< Reference< chart2::data::XLabeledDataSequence > > aDataSeqences( xSeriesSource->getDataSequences() );
 252
 253     //the first x-values is always the next sequence //todo ... other x-values get lost for old format
 254     Reference< chart2::data::XLabeledDataSequence > xXValues(
 255         DataSeriesHelper::getDataSequenceByRole( xSeriesSource, C2U("values-x") ) );
 256     if( xXValues.is() )
 257         aResultVector.push_back( xXValues );
 258
 259     //add all other sequences now without x-values
 260     for( sal_Int32 nN=0; nN<aDataSeqences.getLength(); nN++ )
 261     {
 262         OUString aRole( DataSeriesHelper::GetRole( aDataSeqences[nN] ) );
 263         if( !aRole.equals(C2U("values-x")) )
 264             aResultVector.push_back( aDataSeqences[nN] );
 265     }
 266
 267     Sequence< Reference< chart2::data::XLabeledDataSequence > > aResultSequence( aResultVector.size() );
 268     ::std::copy( aResultVector.begin(), aResultVector.end(), aResultSequence.getArray() );
 269
 270     return new DataSource( aResultSequence );
 271 }
 272
 273 uno::Sequence< ::rtl::OUString > DataSourceHelper::getUsedDataRanges(
 274     const uno::Reference< chart2::XDiagram > & xDiagram )
 275 {
 276     ::std::vector< ::rtl::OUString > aResult;
 277
 278     if( xDiagram.is())
 279     {
 280         uno::Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
 281         if( xCategories.is() )
 282             lcl_addRanges( aResult, xCategories );
 283
 284         ::std::vector< uno::Reference< XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
 285         for( ::std::vector< uno::Reference< XDataSeries > >::const_iterator aSeriesIt( aSeriesVector.begin() )
 286                  ; aSeriesIt != aSeriesVector.end(); ++aSeriesIt )
 287         {
 288             uno::Reference< data::XDataSource > xDataSource( *aSeriesIt, uno::UNO_QUERY );
 289             lcl_addDataSourceRanges( aResult, xDataSource );
 290             lcl_addErrorBarRanges( aResult, *aSeriesIt );
 291         }
 292     }
 293
 294     return ContainerHelper::ContainerToSequence( aResult );
 295 }
 296
 297 uno::Sequence< ::rtl::OUString > DataSourceHelper::getUsedDataRanges( const uno::Reference< frame::XModel > & xChartModel )
 298 {
 299     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
 300     return getUsedDataRanges( xDiagram );
 301 }
 302
 303 uno::Reference< chart2::data::XDataSource > DataSourceHelper::getUsedData(
 304     const uno::Reference< chart2::XChartDocument >& xChartDoc,
 305     bool bIncludeUnusedData /* = false */ )
 306 {
 307     if( bIncludeUnusedData )
 308         return getUsedData( uno::Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ), bIncludeUnusedData );
 309     else
 310          return pressUsedDataIntoRectangularFormat( xChartDoc );
 311 }
 312
 313 uno::Reference< chart2::data::XDataSource > DataSourceHelper::getUsedData(
 314     const uno::Reference< frame::XModel >& xChartModel,
 315     bool bIncludeUnusedData /* = false */ )
 316 {
 317     ::std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > aResult;
 318
 319     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
 320     uno::Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
 321     if( xCategories.is() )
 322         aResult.push_back( xCategories );
 323
 324     ::std::vector< uno::Reference< XDataSeries > > aSeriesVector( ChartModelHelper::getDataSeries( xChartModel ) );
 325     for( ::std::vector< uno::Reference< XDataSeries > >::const_iterator aSeriesIt( aSeriesVector.begin() )
 326         ; aSeriesIt != aSeriesVector.end(); ++aSeriesIt )
 327     {
 328         uno::Reference< data::XDataSource > xDataSource( *aSeriesIt, uno::UNO_QUERY );
 329         if( !xDataSource.is() )
 330             continue;
 331         uno::Sequence< uno::Reference< data::XLabeledDataSequence > > aDataSequences( xDataSource->getDataSequences() );
 332         ::std::copy( aDataSequences.getConstArray(), aDataSequences.getConstArray() + aDataSequences.getLength(),
 333                      ::std::back_inserter( aResult ));
 334     }
 335
 336     if( bIncludeUnusedData && xDiagram.is())
 337     {
 338         uno::Sequence< uno::Reference< data::XLabeledDataSequence > > aUnusedData( xDiagram->getUnusedData());
 339         ::std::copy( aUnusedData.getConstArray(),
 340                      aUnusedData.getConstArray() + aUnusedData.getLength(),
 341                      ::std::back_inserter( aResult ));
 342     }
 343
 344     return uno::Reference< chart2::data::XDataSource >(
 345         new DataSource( ContainerHelper::ContainerToSequence( aResult )));
 346 }
 347
 348 bool DataSourceHelper::detectRangeSegmentation(
 349     const uno::Reference<
 350         frame::XModel >& xChartModel
 351     , ::rtl::OUString& rOutRangeString
 352     , ::com::sun::star::uno::Sequence< sal_Int32 >& rSequenceMapping
 353     , bool& rOutUseColumns
 354     , bool& rOutFirstCellAsLabel
 355     , bool& rOutHasCategories
 356     , bool bIncludeUnusedData /* = false */)
 357 {
 358     bool bSomethingDetected = false;
 359
 360     uno::Reference< XChartDocument > xChartDocument( xChartModel, uno::UNO_QUERY );
 361     if( !xChartDocument.is() )
 362         return bSomethingDetected;
 363     uno::Reference< data::XDataProvider >  xDataProvider( xChartDocument->getDataProvider() );
 364     if( !xDataProvider.is() )
 365         return bSomethingDetected;
 366
 367     OSL_ASSERT( !bIncludeUnusedData ); //bIncludeUnusedData is not supported currently
 368     (void)(bIncludeUnusedData); // avoid warning in non-debug build
 369
 370     try
 371     {
 372         DataSourceHelper::readArguments(
 373             xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartDocument ) ),
 374             rOutRangeString, rSequenceMapping, rOutUseColumns, rOutFirstCellAsLabel, rOutHasCategories );
 375         bSomethingDetected = (rOutRangeString.getLength() > 0);
 376
 377         uno::Reference< chart2::data::XLabeledDataSequence > xCategories(
 378                     DiagramHelper::getCategoriesFromDiagram( xChartDocument->getFirstDiagram() ));
 379         rOutHasCategories = xCategories.is();
 380     }
 381     catch( uno::Exception & ex )
 382     {
 383         ASSERT_EXCEPTION( ex );
 384     }
 385     return bSomethingDetected;
 386 }
 387
 388 bool DataSourceHelper::allArgumentsForRectRangeDetected(
 389     const uno::Reference< chart2::XChartDocument >& xChartDocument )
 390 {
 391     bool bHasDataRowSource = false;
 392     bool bHasFirstCellAsLabel = false;
 393 //     bool bHasHasCategories = false;
 394     bool bHasCellRangeRepresentation = false;
 395 //     bool bHasSequenceMapping = false;
 396
 397     uno::Reference< data::XDataProvider > xDataProvider( xChartDocument->getDataProvider() );
 398     if( !xDataProvider.is() )
 399         return false;
 400
 401     try
 402     {
 403         const uno::Sequence< beans::PropertyValue > aArguments(
 404             xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartDocument )));
 405         const beans::PropertyValue* pArguments = aArguments.getConstArray();
 406         for(sal_Int32 i=0; i<aArguments.getLength(); ++i, ++pArguments)
 407         {
 408             const beans::PropertyValue& aProperty = *pArguments;
 409             if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DataRowSource" ) ))
 410             {
 411                 bHasDataRowSource =
 412                     (aProperty.Value.hasValue() && aProperty.Value.isExtractableTo(
 413                         ::getCppuType( reinterpret_cast<
 414                                        const ::com::sun::star::chart::ChartDataRowSource * >(0))));
 415             }
 416             else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FirstCellAsLabel" ) ))
 417             {
 418                 bHasFirstCellAsLabel =
 419                     (aProperty.Value.hasValue() && aProperty.Value.isExtractableTo(::getBooleanCppuType()));
 420             }
 421 //             else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "HasCategories" ) ))
 422 //             {
 423 //                 bHasHasCategories =
 424 //                     (aProperty.Value.hasValue() && aProperty.Value.isExtractableTo(::getBooleanCppuType()));
 425 //             }
 426             else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CellRangeRepresentation" ) ))
 427             {
 428                 ::rtl::OUString aRange;
 429                 bHasCellRangeRepresentation =
 430                     (aProperty.Value.hasValue() && (aProperty.Value >>= aRange) && aRange.getLength() > 0);
 431             }
 432 //         else if( aProperty.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "SequenceMapping" ) ))
 433 //         {
 434 //             bHasSequenceMapping =
 435 //                 (aProperty.Value.hasValue() && aProperty.Value.isExtractableTo(
 436 //                     ::getCppuType( reinterpret_cast<
 437 //                                    const uno::Sequence< sal_Int32 > * >(0))));
 438 //         }
 439         }
 440     }
 441     catch( const uno::Exception & ex )
 442     {
 443         ASSERT_EXCEPTION( ex );
 444     }
 445
 446     return (bHasCellRangeRepresentation && bHasDataRowSource && bHasFirstCellAsLabel);
 447 }
 448
 449 void DataSourceHelper::setRangeSegmentation(
 450             const uno::Reference< frame::XModel >& xChartModel
 451             , const ::com::sun::star::uno::Sequence< sal_Int32 >& rSequenceMapping
 452             , bool bUseColumns , bool bFirstCellAsLabel, bool bUseCategories )
 453 {
 454     uno::Reference< XChartDocument > xChartDocument( xChartModel, uno::UNO_QUERY );
 455     if( !xChartDocument.is() )
 456         return;
 457     uno::Reference< data::XDataProvider > xDataProvider( xChartDocument->getDataProvider() );
 458     if( !xDataProvider.is() )
 459         return;
 460     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
 461     if( !xDiagram.is() )
 462         return;
 463     uno::Reference< chart2::XChartTypeManager > xChartTypeManager( xChartDocument->getChartTypeManager() );
 464     if( !xChartTypeManager.is() )
 465         return;
 466     uno::Reference< lang::XMultiServiceFactory > xTemplateFactory( xChartTypeManager, uno::UNO_QUERY );
 467     if( !xTemplateFactory.is() )
 468         return;
 469
 470     ::rtl::OUString aRangeString;
 471     bool bDummy;
 472     uno::Sequence< sal_Int32 > aDummy;
 473     readArguments( xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartDocument )),
 474                    aRangeString, aDummy, bDummy, bDummy, bDummy );
 475
 476     uno::Sequence< beans::PropertyValue > aArguments(
 477         createArguments( aRangeString, rSequenceMapping, bUseColumns, bFirstCellAsLabel, bUseCategories ) );
 478
 479     uno::Reference< chart2::data::XDataSource > xDataSource( xDataProvider->createDataSource(
 480                                                                  aArguments ) );
 481     if( !xDataSource.is() )
 482         return;
 483
 484     DiagramHelper::tTemplateWithServiceName aTemplateAndService =
 485         DiagramHelper::getTemplateForDiagram( xDiagram, xTemplateFactory );
 486
 487     rtl::OUString aServiceName( aTemplateAndService.second );
 488     uno::Reference< chart2::XChartTypeTemplate > xTemplate = aTemplateAndService.first;
 489
 490     if( !xTemplate.is() )
 491     {
 492         if( aServiceName.getLength() == 0 )
 493             aServiceName = C2U("com.sun.star.chart2.template.Column");
 494         xTemplate.set( xTemplateFactory->createInstance( aServiceName ), uno::UNO_QUERY );
 495     }
 496     if( !xTemplate.is() )
 497         return;
 498
 499     // /-- locked controllers
 500     ControllerLockGuard aCtrlLockGuard( xChartModel );
 501     xTemplate->changeDiagramData( xDiagram, xDataSource, aArguments );
 502     // \-- locked controllers
 503 }
 504
 505 Sequence< OUString > DataSourceHelper::getRangesFromLabeledDataSequence(
 506     const Reference< data::XLabeledDataSequence > & xLSeq )
 507 {
 508     Sequence< OUString > aResult;
 509     if( xLSeq.is())
 510     {
 511         Reference< data::XDataSequence > xLabel( xLSeq->getLabel());
 512         Reference< data::XDataSequence > xValues( xLSeq->getValues());
 513
 514         if( xLabel.is())
 515         {
 516             if( xValues.is())
 517             {
 518                 aResult.realloc( 2 );
 519                 aResult[0] = xLabel->getSourceRangeRepresentation();
 520                 aResult[1] = xValues->getSourceRangeRepresentation();
 521             }
 522             else
 523             {
 524                 aResult.realloc( 1 );
 525                 aResult[0] = xLabel->getSourceRangeRepresentation();
 526             }
 527         }
 528         else if( xValues.is())
 529         {
 530             aResult.realloc( 1 );
 531             aResult[0] = xValues->getSourceRangeRepresentation();
 532         }
 533     }
 534     return aResult;
 535 }
 536
 537 Sequence< OUString > DataSourceHelper::getRangesFromDataSource( const Reference< data::XDataSource > & xSource )
 538 {
 539     ::std::vector< OUString > aResult;
 540     if( xSource.is())
 541     {
 542         Sequence< Reference< data::XLabeledDataSequence > > aLSeqSeq( xSource->getDataSequences());
 543         for( sal_Int32 i=0; i<aLSeqSeq.getLength(); ++i )
 544         {
 545             Reference< data::XDataSequence > xLabel( aLSeqSeq[i]->getLabel());
 546             Reference< data::XDataSequence > xValues( aLSeqSeq[i]->getValues());
 547
 548             if( xLabel.is())
 549                 aResult.push_back( xLabel->getSourceRangeRepresentation());
 550             if( xValues.is())
 551                 aResult.push_back( xValues->getSourceRangeRepresentation());
 552         }
 553     }
 554     return ContainerHelper::ContainerToSequence( aResult );
 555 }
 556
 557 //.............................................................................
 558 } //namespace chart
 559 //.............................................................................