chart2/source/tools/InternalDataProvider.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include <rtl/math.hxx>
  31
  32 #include <valarray>
  33
  34 #include "InternalDataProvider.hxx"
  35 #include "LabeledDataSequence.hxx"
  36 #include "DataSource.hxx"
  37 #include "PropertyHelper.hxx"
  38 #include "macros.hxx"
  39 #include "XMLRangeHelper.hxx"
  40 #include "ContainerHelper.hxx"
  41 #include "CommonConverters.hxx"
  42 #include "CommonFunctors.hxx"
  43 #include "UncachedDataSequence.hxx"
  44 #include "DataSourceHelper.hxx"
  45 #include "ChartModelHelper.hxx"
  46 #include "DiagramHelper.hxx"
  47 #include "ExplicitCategoriesProvider.hxx"
  48
  49 #include <com/sun/star/chart2/XChartDocument.hpp>
  50 #include <com/sun/star/chart2/data/XDataSequence.hpp>
  51 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  52 #include <rtl/ustrbuf.hxx>
  53 #include <unotools/charclass.hxx>
  54 #include <comphelper/sequenceashashmap.hxx>
  55
  56 #include <vector>
  57 #include <algorithm>
  58
  59 using namespace ::com::sun::star;
  60 using namespace ::std;
  61
  62 using ::com::sun::star::uno::Reference;
  63 using ::com::sun::star::uno::Sequence;
  64 using ::rtl::OUString;
  65 using ::rtl::OUStringBuffer;
  66
  67 namespace chart
  68 {
  69
  70 // ================================================================================
  71
  72 namespace
  73 {
  74
  75 // note: in xmloff this name is used to indicate usage of own data
  76 static const ::rtl::OUString lcl_aServiceName(
  77     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.chart.InternalDataProvider" ));
  78
  79 static const ::rtl::OUString lcl_aCategoriesRangeName(
  80     RTL_CONSTASCII_USTRINGPARAM( "categories" ));
  81 static const ::rtl::OUString lcl_aCategoriesLevelRangeNamePrefix(
  82     RTL_CONSTASCII_USTRINGPARAM( "categoriesL " )); //L <-> level
  83 static const ::rtl::OUString lcl_aCategoriesPointRangeNamePrefix(
  84     RTL_CONSTASCII_USTRINGPARAM( "categoriesP " )); //P <-> point
  85 static const ::rtl::OUString lcl_aCategoriesRoleName(
  86     RTL_CONSTASCII_USTRINGPARAM( "categories" ));
  87 static const ::rtl::OUString lcl_aLabelRangePrefix(
  88     RTL_CONSTASCII_USTRINGPARAM( "label " ));
  89 static const ::rtl::OUString lcl_aCompleteRange(
  90     RTL_CONSTASCII_USTRINGPARAM( "all" ));
  91
  92 typedef ::std::multimap< OUString, uno::WeakReference< chart2::data::XDataSequence > >
  93     lcl_tSequenceMap;
  94
  95 Sequence< OUString > lcl_AnyToStringSequence( const Sequence< uno::Any >& aAnySeq )
  96 {
  97     Sequence< OUString > aResult;
  98     aResult.realloc( aAnySeq.getLength() );
  99     transform( aAnySeq.getConstArray(), aAnySeq.getConstArray() + aAnySeq.getLength(),
 100                aResult.getArray(), CommonFunctors::AnyToString() );
 101     return aResult;
 102 }
 103
 104 Sequence< uno::Any > lcl_StringToAnySequence( const Sequence< OUString >& aStringSeq )
 105 {
 106     Sequence< uno::Any > aResult;
 107     aResult.realloc( aStringSeq.getLength() );
 108     transform( aStringSeq.getConstArray(), aStringSeq.getConstArray() + aStringSeq.getLength(),
 109                aResult.getArray(), CommonFunctors::makeAny< OUString >() );
 110     return aResult;
 111 }
 112
 113 struct lcl_setModified : public ::std::unary_function< lcl_tSequenceMap, void >
 114 {
 115     void operator() ( const lcl_tSequenceMap::value_type & rMapEntry )
 116     {
 117         // convert weak reference to reference
 118         Reference< chart2::data::XDataSequence > xSeq( rMapEntry.second );
 119         if( xSeq.is())
 120         {
 121             Reference< util::XModifiable > xMod( xSeq, uno::UNO_QUERY );
 122             if( xMod.is())
 123                 xMod->setModified( sal_True );
 124         }
 125     }
 126 };
 127
 128 struct lcl_internalizeSeries : public ::std::unary_function< Reference< chart2::XDataSeries >, void >
 129 {
 130     lcl_internalizeSeries( InternalData & rInternalData,
 131                            InternalDataProvider & rProvider,
 132                            bool bConnectToModel, bool bDataInColumns ) :
 133             m_rInternalData( rInternalData ),
 134             m_rProvider( rProvider ),
 135             m_bConnectToModel( bConnectToModel ),
 136             m_bDataInColumns( bDataInColumns )
 137     {}
 138     void operator() ( const Reference< chart2::XDataSeries > & xSeries )
 139     {
 140         Reference< chart2::data::XDataSource > xSource( xSeries, uno::UNO_QUERY );
 141         Reference< chart2::data::XDataSink >   xSink(   xSeries, uno::UNO_QUERY );
 142         if( xSource.is() && xSink.is() )
 143         {
 144             Sequence< Reference< chart2::data::XLabeledDataSequence > > aOldSeriesData = xSource->getDataSequences();
 145             Sequence< Reference< chart2::data::XLabeledDataSequence > > aNewSeriesData( aOldSeriesData.getLength() );
 146             for( sal_Int32 i=0; i<aOldSeriesData.getLength(); ++i )
 147             {
 148                 sal_Int32 nNewIndex( m_bDataInColumns ? m_rInternalData.appendColumn() : m_rInternalData.appendRow() );
 149                 OUString aIdentifier( OUString::valueOf( nNewIndex ));
 150                 //@todo: deal also with genericXDataSequence
 151                 Reference< chart2::data::XNumericalDataSequence > xValues( aOldSeriesData[i]->getValues(), uno::UNO_QUERY );
 152                 Reference< chart2::data::XTextualDataSequence > xLabel( aOldSeriesData[i]->getLabel(), uno::UNO_QUERY );
 153                 Reference< chart2::data::XDataSequence > xNewValues;
 154
 155                 if( xValues.is() )
 156                 {
 157                     ::std::vector< double > aValues( ContainerHelper::SequenceToVector( xValues->getNumericalData()));
 158                     if( m_bDataInColumns )
 159                         m_rInternalData.setColumnValues( nNewIndex, aValues );
 160                     else
 161                         m_rInternalData.setRowValues( nNewIndex, aValues );
 162                     if( m_bConnectToModel )
 163                     {
 164                         xNewValues.set( m_rProvider.createDataSequenceByRangeRepresentation( aIdentifier ));
 165                         comphelper::copyProperties(
 166                             Reference< beans::XPropertySet >( xValues, uno::UNO_QUERY ),
 167                             Reference< beans::XPropertySet >( xNewValues, uno::UNO_QUERY ));
 168                     }
 169                 }
 170
 171                 if( xLabel.is() )
 172                 {
 173                     if( m_bDataInColumns )
 174                         m_rInternalData.setComplexColumnLabel( nNewIndex, ContainerHelper::SequenceToVector( lcl_StringToAnySequence( xLabel->getTextualData() ) ) );
 175                     else
 176                         m_rInternalData.setComplexRowLabel( nNewIndex, ContainerHelper::SequenceToVector( lcl_StringToAnySequence( xLabel->getTextualData() ) ) );
 177                     if( m_bConnectToModel )
 178                     {
 179                         Reference< chart2::data::XDataSequence > xNewLabel(
 180                             m_rProvider.createDataSequenceByRangeRepresentation( lcl_aLabelRangePrefix + aIdentifier ));
 181                         comphelper::copyProperties(
 182                             Reference< beans::XPropertySet >( xLabel, uno::UNO_QUERY ),
 183                             Reference< beans::XPropertySet >( xNewLabel, uno::UNO_QUERY ));
 184                         aNewSeriesData[i] = Reference< chart2::data::XLabeledDataSequence >(
 185                                 new LabeledDataSequence( xNewValues, xNewLabel ));
 186                     }
 187                 }
 188                 else
 189                 {
 190                     if( m_bConnectToModel )
 191                         aNewSeriesData[i] = Reference< chart2::data::XLabeledDataSequence >(
 192                             new LabeledDataSequence( xNewValues ));
 193                 }
 194             }
 195             if( m_bConnectToModel )
 196                 xSink->setData( aNewSeriesData );
 197         }
 198      }
 199
 200 private:
 201     InternalData &          m_rInternalData;
 202     InternalDataProvider &  m_rProvider;
 203     bool                    m_bConnectToModel;
 204     bool                    m_bDataInColumns;
 205 };
 206
 207 struct lcl_copyFromLevel : public ::std::unary_function< vector< uno::Any >, uno::Any >
 208 {
 209 public:
 210
 211     explicit lcl_copyFromLevel( sal_Int32 nLevel ) : m_nLevel( nLevel )
 212     {}
 213
 214     uno::Any operator() ( const vector< uno::Any >& rVector )
 215     {
 216         uno::Any aRet;
 217         if( m_nLevel <  static_cast< sal_Int32 >(rVector.size()) )
 218             aRet = rVector[m_nLevel];
 219         return aRet;
 220     }
 221
 222 private:
 223     sal_Int32 m_nLevel;
 224 };
 225
 226 struct lcl_getStringFromLevelVector : public ::std::unary_function< vector< uno::Any >, OUString >
 227 {
 228 public:
 229
 230     explicit lcl_getStringFromLevelVector( sal_Int32 nLevel ) : m_nLevel( nLevel )
 231     {}
 232
 233     OUString operator() ( const vector< uno::Any >& rVector )
 234     {
 235         OUString aString;
 236         if( m_nLevel < static_cast< sal_Int32 >(rVector.size()) )
 237             aString = CommonFunctors::AnyToString()(rVector[m_nLevel]);
 238         return aString;
 239     }
 240
 241 private:
 242     sal_Int32 m_nLevel;
 243 };
 244
 245
 246 struct lcl_setAnyAtLevel : public ::std::binary_function< vector< uno::Any >, uno::Any, vector< uno::Any > >
 247 {
 248 public:
 249
 250     explicit lcl_setAnyAtLevel( sal_Int32 nLevel ) : m_nLevel( nLevel )
 251     {}
 252
 253     vector< uno::Any > operator() ( const vector< uno::Any >& rVector, const uno::Any& rNewValue )
 254     {
 255         vector< uno::Any > aRet( rVector );
 256         if( m_nLevel >= static_cast< sal_Int32 >(aRet.size()) )
 257             aRet.resize( m_nLevel+1 );
 258         aRet[ m_nLevel ]=rNewValue;
 259         return aRet;
 260     }
 261
 262 private:
 263     sal_Int32 m_nLevel;
 264 };
 265
 266 struct lcl_setAnyAtLevelFromStringSequence : public ::std::binary_function< vector< uno::Any >, OUString, vector< uno::Any > >
 267 {
 268 public:
 269
 270     explicit lcl_setAnyAtLevelFromStringSequence( sal_Int32 nLevel ) : m_nLevel( nLevel )
 271     {}
 272
 273     vector< uno::Any > operator() ( const vector< uno::Any >& rVector, const OUString& rNewValue )
 274     {
 275         vector< uno::Any > aRet( rVector );
 276         if( m_nLevel >= static_cast< sal_Int32 >(aRet.size()) )
 277             aRet.resize( m_nLevel+1 );
 278         aRet[ m_nLevel ]=uno::makeAny(rNewValue);
 279         return aRet;
 280     }
 281
 282 private:
 283     sal_Int32 m_nLevel;
 284 };
 285
 286 struct lcl_insertAnyAtLevel : public ::std::unary_function< vector< uno::Any >, void >
 287 {
 288 public:
 289
 290     explicit lcl_insertAnyAtLevel( sal_Int32 nLevel ) : m_nLevel( nLevel )
 291     {}
 292
 293     void operator() ( vector< uno::Any >& rVector )
 294     {
 295         if( m_nLevel > static_cast< sal_Int32 >(rVector.size()) )
 296             rVector.resize( m_nLevel );
 297
 298         vector< uno::Any >::iterator aIt( rVector.begin() );
 299         for( sal_Int32 nN=0; aIt<rVector.end(); aIt++, nN++)
 300         {
 301             if( nN==m_nLevel )
 302                 break;
 303         }
 304         rVector.insert( aIt, uno::Any() );
 305     }
 306
 307 private:
 308     sal_Int32 m_nLevel;
 309 };
 310
 311 struct lcl_removeAnyAtLevel : public ::std::unary_function< vector< uno::Any >, void >
 312 {
 313 public:
 314
 315     explicit lcl_removeAnyAtLevel( sal_Int32 nLevel ) : m_nLevel( nLevel )
 316     {}
 317
 318     void operator() ( vector< uno::Any >& rVector )
 319     {
 320         vector< uno::Any >::iterator aIt( rVector.begin() );
 321         for( sal_Int32 nN=0; aIt<rVector.end(); aIt++, nN++)
 322         {
 323             if( nN==m_nLevel )
 324             {
 325                 rVector.erase( aIt );
 326                 break;
 327             }
 328         }
 329     }
 330
 331 private:
 332     sal_Int32 m_nLevel;
 333 };
 334
 335 } // anonymous namespace
 336
 337 // ================================================================================
 338
 339 InternalDataProvider::InternalDataProvider( const Reference< uno::XComponentContext > & /*_xContext*/)
 340     : m_bDataInColumns( true )
 341 {}
 342
 343 InternalDataProvider::InternalDataProvider( const Reference< chart2::XChartDocument > & xChartDoc, bool bConnectToModel )
 344     : m_bDataInColumns( true )
 345 {
 346     try
 347     {
 348         Reference< chart2::XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartDoc ) );
 349         if( xDiagram.is())
 350         {
 351             Reference< frame::XModel > xChartModel( xChartDoc, uno::UNO_QUERY );
 352
 353             //data in columns?
 354             {
 355                 ::rtl::OUString aRangeString;
 356                 bool bFirstCellAsLabel = true;
 357                 bool bHasCategories = true;
 358                 uno::Sequence< sal_Int32 > aSequenceMapping;
 359                 DataSourceHelper::detectRangeSegmentation( xChartModel, aRangeString, aSequenceMapping, m_bDataInColumns, bFirstCellAsLabel, bHasCategories );
 360             }
 361
 362             // categories
 363             {
 364                 vector< vector< uno::Any > > aNewCategories;//inner count is level
 365                 {
 366                     ExplicitCategoriesProvider aExplicitCategoriesProvider( ChartModelHelper::getFirstCoordinateSystem(xChartModel), xChartModel );
 367
 368                     const Sequence< Reference< chart2::data::XLabeledDataSequence> >& rSplitCategoriesList( aExplicitCategoriesProvider.getSplitCategoriesList() );
 369                     sal_Int32 nLevelCount = rSplitCategoriesList.getLength();
 370                     for( sal_Int32 nL = 0; nL<nLevelCount; nL++ )
 371                     {
 372                         Reference< chart2::data::XLabeledDataSequence > xLDS( rSplitCategoriesList[nL] );
 373                         if( !xLDS.is() )
 374                             continue;
 375                         Sequence< uno::Any > aDataSeq;
 376                         Reference< chart2::data::XDataSequence > xSeq( xLDS->getValues() );
 377                         if( xSeq.is() )
 378                             aDataSeq = xSeq->getData();
 379                         sal_Int32 nLength = aDataSeq.getLength();
 380                         sal_Int32 nCatLength = static_cast< sal_Int32 >(aNewCategories.size());
 381                         if( nCatLength < nLength )
 382                             aNewCategories.resize( nLength );
 383                         else if( nLength < nCatLength )
 384                             aDataSeq.realloc( nCatLength );
 385                         transform( aNewCategories.begin(), aNewCategories.end(), aDataSeq.getConstArray(),
 386                             aNewCategories.begin(), lcl_setAnyAtLevel(nL) );
 387                     }
 388                     if( !nLevelCount )
 389                     {
 390                         Sequence< OUString > aSimplecategories = aExplicitCategoriesProvider.getSimpleCategories();
 391                         sal_Int32 nLength = aSimplecategories.getLength();
 392                         aNewCategories.reserve( nLength );
 393                         for( sal_Int32 nN=0; nN<nLength; nN++)
 394                         {
 395                             vector< uno::Any > aVector(1);
 396                             aVector[0] = uno::makeAny( aSimplecategories[nN] );
 397                             aNewCategories.push_back( aVector );
 398                         }
 399                     }
 400                 }
 401
 402                 if( m_bDataInColumns )
 403                     m_aInternalData.setComplexRowLabels( aNewCategories );
 404                 else
 405                     m_aInternalData.setComplexColumnLabels( aNewCategories );
 406                 if( bConnectToModel )
 407                     DiagramHelper::setCategoriesToDiagram( new LabeledDataSequence(
 408                         createDataSequenceByRangeRepresentation( lcl_aCategoriesRangeName )), xDiagram );
 409             }
 410
 411             // data series
 412             ::std::vector< Reference< chart2::XDataSeries > > aSeriesVector( ChartModelHelper::getDataSeries( xChartDoc ));
 413             ::std::for_each( aSeriesVector.begin(), aSeriesVector.end(), lcl_internalizeSeries( m_aInternalData, *this, bConnectToModel, m_bDataInColumns ) );
 414         }
 415     }
 416     catch( const uno::Exception & ex )
 417     {
 418         ASSERT_EXCEPTION( ex );
 419     }
 420 }
 421
 422 // copy-CTOR
 423 InternalDataProvider::InternalDataProvider( const InternalDataProvider & rOther ) :
 424         impl::InternalDataProvider_Base(),
 425         m_aSequenceMap( rOther.m_aSequenceMap ),
 426         m_aInternalData( rOther.m_aInternalData ),
 427         m_bDataInColumns( rOther.m_bDataInColumns )
 428 {}
 429
 430 InternalDataProvider::~InternalDataProvider()
 431 {}
 432
 433 void InternalDataProvider::lcl_addDataSequenceToMap(
 434     const OUString & rRangeRepresentation,
 435     const Reference< chart2::data::XDataSequence > & xSequence )
 436 {
 437     m_aSequenceMap.insert(
 438         tSequenceMap::value_type(
 439             rRangeRepresentation,
 440             uno::WeakReference< chart2::data::XDataSequence >( xSequence )));
 441 }
 442
 443 void InternalDataProvider::lcl_deleteMapReferences( const OUString & rRangeRepresentation )
 444 {
 445     // set sequence to deleted by setting its range to an empty string
 446     tSequenceMapRange aRange( m_aSequenceMap.equal_range( rRangeRepresentation ));
 447     for( tSequenceMap::iterator aIt( aRange.first ); aIt != aRange.second; ++aIt )
 448     {
 449         Reference< chart2::data::XDataSequence > xSeq( aIt->second );
 450         if( xSeq.is())
 451         {
 452             Reference< container::XNamed > xNamed( xSeq, uno::UNO_QUERY );
 453             if( xNamed.is())
 454                 xNamed->setName( OUString());
 455         }
 456     }
 457     // remove from map
 458     m_aSequenceMap.erase( aRange.first, aRange.second );
 459 }
 460
 461 void InternalDataProvider::lcl_adaptMapReferences(
 462     const OUString & rOldRangeRepresentation,
 463     const OUString & rNewRangeRepresentation )
 464 {
 465     tSequenceMapRange aRange( m_aSequenceMap.equal_range( rOldRangeRepresentation ));
 466     tSequenceMap aNewElements;
 467     for( tSequenceMap::iterator aIt( aRange.first ); aIt != aRange.second; ++aIt )
 468     {
 469         Reference< chart2::data::XDataSequence > xSeq( aIt->second );
 470         if( xSeq.is())
 471         {
 472             Reference< container::XNamed > xNamed( xSeq, uno::UNO_QUERY );
 473             if( xNamed.is())
 474                 xNamed->setName( rNewRangeRepresentation );
 475         }
 476         aNewElements.insert( tSequenceMap::value_type( rNewRangeRepresentation, aIt->second ));
 477     }
 478     // erase map values for old index
 479     m_aSequenceMap.erase( aRange.first, aRange.second );
 480     // add new entries for values with new index
 481     ::std::copy( aNewElements.begin(), aNewElements.end(),
 482                  ::std::inserter( m_aSequenceMap,
 483                                   m_aSequenceMap.upper_bound( rNewRangeRepresentation )));
 484 }
 485
 486 void InternalDataProvider::lcl_increaseMapReferences(
 487     sal_Int32 nBegin, sal_Int32 nEnd )
 488 {
 489     for( sal_Int32 nIndex = nEnd - 1; nIndex >= nBegin; --nIndex )
 490     {
 491         lcl_adaptMapReferences( OUString::valueOf( nIndex ),
 492                             OUString::valueOf( nIndex + 1 ));
 493         lcl_adaptMapReferences( lcl_aLabelRangePrefix + OUString::valueOf( nIndex ),
 494                             lcl_aLabelRangePrefix + OUString::valueOf( nIndex + 1 ));
 495     }
 496 }
 497
 498 void InternalDataProvider::lcl_decreaseMapReferences(
 499     sal_Int32 nBegin, sal_Int32 nEnd )
 500 {
 501     for( sal_Int32 nIndex = nBegin; nIndex < nEnd; ++nIndex )
 502     {
 503         lcl_adaptMapReferences( OUString::valueOf( nIndex ),
 504                             OUString::valueOf( nIndex - 1 ));
 505         lcl_adaptMapReferences( lcl_aLabelRangePrefix + OUString::valueOf( nIndex ),
 506                             lcl_aLabelRangePrefix + OUString::valueOf( nIndex - 1 ));
 507     }
 508 }
 509
 510 Reference< chart2::data::XDataSequence > InternalDataProvider::lcl_createDataSequenceAndAddToMap(
 511     const OUString & rRangeRepresentation )
 512 {
 513     OUString aRangeRepresentation = rRangeRepresentation;
 514     if( aRangeRepresentation.indexOf('{') >= 0 )
 515     {
 516         ::std::vector< double > aNewData;
 517         ::std::vector< uno::Any > aNewLabels;
 518         OUString    aToken;
 519         sal_Int32   nCategories     = 0;
 520         sal_Int32   nIndex          = 0;
 521         bool        bValues         = true;
 522         bool        bLabelSet       = false;
 523         OUString str = aRangeRepresentation.replace('{',' ').replace('}',' ');
 524
 525         m_aInternalData.clearDefaultData();
 526         sal_Int32 n = m_aInternalData.getColumnCount();
 527         if( n )
 528             n = n - 1;
 529
 530         do
 531         {
 532             // TODO: This will be problematic if ';' is used in label names
 533             // '"' character also needs to be considered in such cases
 534             aToken = str.getToken(0,';',nIndex);
 535             if( aToken.isEmpty() )
 536                 break;
 537             if( aToken.indexOf('"') < 0 )
 538             {
 539                 aNewData.push_back( aToken.toDouble() );
 540             }
 541             else
 542             {
 543                 aNewLabels.push_back( uno::makeAny(aToken.replace('"', ' ').trim()) );
 544                 if( !nCategories &&
 545                    ( !m_aInternalData.getComplexColumnLabel(n).size() ||
 546                      !m_aInternalData.getComplexColumnLabel(n).front().hasValue() ) )
 547                 {
 548                     m_aInternalData.setComplexColumnLabel( n,  aNewLabels );
 549                     bLabelSet = true;
 550                 }
 551                 else
 552                 {
 553                     m_aInternalData.setComplexRowLabel(nCategories, aNewLabels);
 554                     if(nCategories==1 && bLabelSet)
 555                     {
 556                         ::std::vector< uno::Any > aLabels;
 557                         m_aInternalData.setComplexRowLabel( 0, m_aInternalData.getComplexColumnLabel( n ) );
 558                         m_aInternalData.setComplexColumnLabel( n, aLabels );
 559                     }
 560                 }
 561                 aNewLabels.pop_back();
 562                 nCategories++;
 563                 bValues = false;
 564             }
 565         } while( nIndex >= 0 );
 566
 567         if( bValues )
 568         {
 569             m_aInternalData.insertColumn( n );
 570             m_aInternalData.setColumnValues( n, aNewData );
 571             aRangeRepresentation = OUString::valueOf( n );
 572         }
 573         else if( nCategories > 1 )
 574         {
 575             aRangeRepresentation = lcl_aCategoriesRangeName;
 576         }
 577         else
 578         {
 579             aRangeRepresentation = lcl_aLabelRangePrefix+OUString::valueOf( n );
 580         }
 581     }
 582
 583     Reference< chart2::data::XDataSequence > xSeq(
 584         new UncachedDataSequence( this, aRangeRepresentation ));
 585     lcl_addDataSequenceToMap( aRangeRepresentation, xSeq );
 586     return xSeq;
 587 }
 588
 589 Reference< chart2::data::XDataSequence > InternalDataProvider::lcl_createDataSequenceAndAddToMap(
 590     const OUString & rRangeRepresentation,
 591     const OUString & rRole )
 592 {
 593     Reference< chart2::data::XDataSequence > xSeq(
 594         new UncachedDataSequence( this, rRangeRepresentation, rRole ));
 595     lcl_addDataSequenceToMap( rRangeRepresentation, xSeq );
 596     return xSeq;
 597 }
 598
 599 void InternalDataProvider::createDefaultData()
 600 {
 601     m_aInternalData.createDefaultData();
 602 }
 603
 604 // ____ XDataProvider ____
 605 ::sal_Bool SAL_CALL InternalDataProvider::createDataSourcePossible( const Sequence< beans::PropertyValue >& /* aArguments */ )
 606     throw (uno::RuntimeException)
 607 {
 608     return true;
 609 }
 610
 611 namespace
 612 {
 613
 614 sal_Int32 lcl_getInnerLevelCount( const vector< vector< uno::Any > >& rLabels )
 615 {
 616     sal_Int32 nCount = 1;//minimum is 1!
 617     vector< vector< uno::Any > >::const_iterator aLevelIt( rLabels.begin() );
 618     vector< vector< uno::Any > >::const_iterator aLevelEnd( rLabels.end() );
 619     for( ;aLevelIt!=aLevelEnd; ++aLevelIt )
 620     {
 621         const vector< uno::Any >& rCurrentLevelLabels = *aLevelIt;
 622         nCount = std::max<sal_Int32>( rCurrentLevelLabels.size(), nCount );
 623     }
 624     return nCount;
 625 }
 626
 627 }//end anonymous namespace
 628
 629 Reference< chart2::data::XDataSource > SAL_CALL InternalDataProvider::createDataSource(
 630     const Sequence< beans::PropertyValue >& aArguments )
 631     throw (lang::IllegalArgumentException,
 632            uno::RuntimeException)
 633 {
 634     OUString aRangeRepresentation;
 635     bool bUseColumns = true;
 636     bool bFirstCellAsLabel = true;
 637     bool bHasCategories = true;
 638     uno::Sequence< sal_Int32 > aSequenceMapping;
 639     DataSourceHelper::readArguments( aArguments, aRangeRepresentation, aSequenceMapping, bUseColumns, bFirstCellAsLabel, bHasCategories );
 640
 641     if( aRangeRepresentation.equals( lcl_aCategoriesRangeName ) )
 642     {
 643         //return split complex categories if we have any:
 644         ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aComplexCategories;
 645         vector< vector< uno::Any > > aCategories( m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels());
 646         if( bUseColumns==m_bDataInColumns )
 647         {
 648             sal_Int32 nLevelCount = lcl_getInnerLevelCount( aCategories );
 649             for( sal_Int32 nL=0; nL<nLevelCount; nL++ )
 650                 aComplexCategories.push_back( new LabeledDataSequence(
 651                     new UncachedDataSequence( this
 652                         , lcl_aCategoriesLevelRangeNamePrefix + OUString::valueOf( nL )
 653                         , lcl_aCategoriesRoleName ) ) );
 654         }
 655         else
 656         {
 657             sal_Int32 nPointCount = m_bDataInColumns ? m_aInternalData.getRowCount() : m_aInternalData.getColumnCount();
 658             for( sal_Int32 nP=0; nP<nPointCount; nP++ )
 659                 aComplexCategories.push_back( new LabeledDataSequence(
 660                     new UncachedDataSequence( this
 661                         , lcl_aCategoriesPointRangeNamePrefix + OUString::valueOf( nP )
 662                         , lcl_aCategoriesRoleName ) ) );
 663         }
 664         //don't add the created sequences to the map as they are used temporarily only ...
 665         return new DataSource( ContainerHelper::ContainerToSequence(aComplexCategories) );
 666     }
 667
 668     OSL_ASSERT( aRangeRepresentation.equals( lcl_aCompleteRange ));
 669
 670     ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aResultLSeqVec;
 671
 672     // categories
 673     if( bHasCategories )
 674         aResultLSeqVec.push_back(
 675             new LabeledDataSequence( lcl_createDataSequenceAndAddToMap( lcl_aCategoriesRangeName, lcl_aCategoriesRoleName ) ) );
 676
 677     // data with labels
 678     ::std::vector< Reference< chart2::data::XLabeledDataSequence > > aDataVec;
 679     const sal_Int32 nCount = (bUseColumns ? m_aInternalData.getColumnCount() : m_aInternalData.getRowCount());
 680     for( sal_Int32 nIdx=0; nIdx<nCount; ++nIdx )
 681     {
 682         aDataVec.push_back(
 683             new LabeledDataSequence(
 684                 lcl_createDataSequenceAndAddToMap( OUString::valueOf( nIdx )),
 685                 lcl_createDataSequenceAndAddToMap( lcl_aLabelRangePrefix + OUString::valueOf( nIdx ))));
 686     }
 687
 688     // attention: this data provider has the limitation that it stores
 689     // internally if data comes from columns or rows. It is intended for
 690     // creating only one used data source.
 691     // @todo: add this information in the range representation strings
 692     m_bDataInColumns = bUseColumns;
 693
 694     //reorder labeled sequences according to aSequenceMapping; ignore categories
 695     for( sal_Int32 nNewIndex = 0; nNewIndex < aSequenceMapping.getLength(); nNewIndex++ )
 696     {
 697         std::vector< LabeledDataSequence* >::size_type nOldIndex = aSequenceMapping[nNewIndex];
 698         if( nOldIndex < aDataVec.size() )
 699         {
 700             if( aDataVec[nOldIndex].is() )
 701             {
 702                 aResultLSeqVec.push_back( aDataVec[nOldIndex] );
 703                 aDataVec[nOldIndex] = 0;
 704             }
 705         }
 706     }
 707
 708     //add left over data sequences to result
 709     ::std::vector< Reference< chart2::data::XLabeledDataSequence > >::iterator aIt(aDataVec.begin());
 710     const ::std::vector< Reference< chart2::data::XLabeledDataSequence > >::const_iterator aEndIt(aDataVec.end());
 711     for( ;aIt!=aEndIt; ++aIt)
 712     {
 713         if( aIt->is() )
 714             aResultLSeqVec.push_back( *aIt );
 715     }
 716
 717     return new DataSource( ContainerHelper::ContainerToSequence(aResultLSeqVec) );
 718 }
 719
 720 Sequence< beans::PropertyValue > SAL_CALL InternalDataProvider::detectArguments(
 721     const Reference< chart2::data::XDataSource >& /* xDataSource */ )
 722     throw (uno::RuntimeException)
 723 {
 724     Sequence< beans::PropertyValue > aArguments( 4 );
 725     aArguments[0] = beans::PropertyValue(
 726         C2U("CellRangeRepresentation"), -1, uno::makeAny( lcl_aCompleteRange ),
 727         beans::PropertyState_DIRECT_VALUE );
 728     aArguments[1] = beans::PropertyValue(
 729         C2U("DataRowSource"), -1, uno::makeAny(
 730             m_bDataInColumns
 731             ? ::com::sun::star::chart::ChartDataRowSource_COLUMNS
 732             : ::com::sun::star::chart::ChartDataRowSource_ROWS ),
 733         beans::PropertyState_DIRECT_VALUE );
 734     // internal data always contains labels and categories
 735     aArguments[2] = beans::PropertyValue(
 736         C2U("FirstCellAsLabel"), -1, uno::makeAny( true ), beans::PropertyState_DIRECT_VALUE );
 737     aArguments[3] = beans::PropertyValue(
 738         C2U("HasCategories"), -1, uno::makeAny( true ), beans::PropertyState_DIRECT_VALUE );
 739
 740     // #i85913# Sequence Mapping is not needed for internal data, as it is
 741     // applied to the data when the data source is created.
 742
 743     return aArguments;
 744 }
 745
 746 ::sal_Bool SAL_CALL InternalDataProvider::createDataSequenceByRangeRepresentationPossible( const OUString& /* aRangeRepresentation */ )
 747     throw (uno::RuntimeException)
 748 {
 749     return true;
 750 }
 751
 752 Reference< chart2::data::XDataSequence > SAL_CALL InternalDataProvider::createDataSequenceByRangeRepresentation(
 753     const OUString& aRangeRepresentation )
 754     throw (lang::IllegalArgumentException,
 755            uno::RuntimeException)
 756 {
 757     if( aRangeRepresentation.match( lcl_aCategoriesRangeName ))
 758     {
 759         OSL_ASSERT( aRangeRepresentation.equals( lcl_aCategoriesRangeName ) );//it is not expected nor implmented that only parts of the categories are really requested
 760
 761         // categories
 762         return lcl_createDataSequenceAndAddToMap( lcl_aCategoriesRangeName, lcl_aCategoriesRoleName );
 763     }
 764     else if( aRangeRepresentation.match( lcl_aLabelRangePrefix ))
 765     {
 766         // label
 767         sal_Int32 nIndex = aRangeRepresentation.copy( lcl_aLabelRangePrefix.getLength()).toInt32();
 768         return lcl_createDataSequenceAndAddToMap( lcl_aLabelRangePrefix + OUString::valueOf( nIndex ));
 769     }
 770     else if ( aRangeRepresentation == "last" )
 771     {
 772         sal_Int32 nIndex = (m_bDataInColumns
 773                             ? m_aInternalData.getColumnCount()
 774                             : m_aInternalData.getRowCount()) - 1;
 775         return lcl_createDataSequenceAndAddToMap( OUString::valueOf( nIndex ));
 776     }
 777     else if( !aRangeRepresentation.isEmpty())
 778     {
 779         // data
 780         return lcl_createDataSequenceAndAddToMap( aRangeRepresentation );
 781     }
 782
 783     return Reference< chart2::data::XDataSequence >();
 784 }
 785
 786 Reference< sheet::XRangeSelection > SAL_CALL InternalDataProvider::getRangeSelection()
 787     throw (uno::RuntimeException)
 788 {
 789     // there is no range selection component
 790     return Reference< sheet::XRangeSelection >();
 791 }
 792
 793 // ____ XInternalDataProvider ____
 794 ::sal_Bool SAL_CALL InternalDataProvider::hasDataByRangeRepresentation( const OUString& aRange )
 795     throw (uno::RuntimeException)
 796 {
 797     sal_Bool bResult = false;
 798
 799     if( aRange.match( lcl_aCategoriesRangeName ))
 800     {
 801         OSL_ASSERT( aRange.equals( lcl_aCategoriesRangeName ) );//it is not expected nor implmented that only parts of the categories are really requested
 802         bResult = true;
 803     }
 804     else if( aRange.match( lcl_aLabelRangePrefix ))
 805     {
 806         sal_Int32 nIndex = aRange.copy( lcl_aLabelRangePrefix.getLength()).toInt32();
 807         bResult = (nIndex < (m_bDataInColumns ? m_aInternalData.getColumnCount(): m_aInternalData.getRowCount()));
 808     }
 809     else
 810     {
 811         sal_Int32 nIndex = aRange.toInt32();
 812         bResult = (nIndex < (m_bDataInColumns ? m_aInternalData.getColumnCount(): m_aInternalData.getRowCount()));
 813     }
 814
 815     return bResult;
 816 }
 817
 818 Sequence< uno::Any > SAL_CALL InternalDataProvider::getDataByRangeRepresentation( const OUString& aRange )
 819     throw (uno::RuntimeException)
 820 {
 821     Sequence< uno::Any > aResult;
 822
 823     if( aRange.match( lcl_aLabelRangePrefix ) )
 824     {
 825         sal_Int32 nIndex = aRange.copy( lcl_aLabelRangePrefix.getLength()).toInt32();
 826         vector< uno::Any > aComplexLabel = m_bDataInColumns
 827             ? m_aInternalData.getComplexColumnLabel( nIndex )
 828             : m_aInternalData.getComplexRowLabel( nIndex );
 829         if( !aComplexLabel.empty() )
 830             aResult = ContainerHelper::ContainerToSequence(aComplexLabel);
 831     }
 832     else if( aRange.match( lcl_aCategoriesPointRangeNamePrefix ) )
 833     {
 834         sal_Int32 nPointIndex = aRange.copy( lcl_aCategoriesPointRangeNamePrefix.getLength() ).toInt32();
 835         vector< uno::Any > aComplexCategory = m_bDataInColumns
 836             ? m_aInternalData.getComplexRowLabel( nPointIndex )
 837             : m_aInternalData.getComplexColumnLabel( nPointIndex );
 838         if( !aComplexCategory.empty() )
 839             aResult = ContainerHelper::ContainerToSequence(aComplexCategory);
 840     }
 841     else if( aRange.match( lcl_aCategoriesLevelRangeNamePrefix ) )
 842     {
 843         sal_Int32 nLevel = aRange.copy( lcl_aCategoriesLevelRangeNamePrefix.getLength() ).toInt32();
 844         vector< vector< uno::Any > > aCategories( m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels());
 845         if( nLevel < lcl_getInnerLevelCount( aCategories ) )
 846         {
 847             aResult.realloc( aCategories.size() );
 848             transform( aCategories.begin(), aCategories.end(),
 849                        aResult.getArray(), lcl_copyFromLevel(nLevel) );
 850         }
 851     }
 852     else if( aRange.equals( lcl_aCategoriesRangeName ) )
 853     {
 854         vector< vector< uno::Any > > aCategories( m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels());
 855         sal_Int32 nLevelCount = lcl_getInnerLevelCount( aCategories );
 856         if( nLevelCount == 1 )
 857         {
 858             sal_Int32 nL=0;
 859             aResult = this->getDataByRangeRepresentation( lcl_aCategoriesLevelRangeNamePrefix + OUString::valueOf( nL ) );
 860         }
 861         else
 862         {
 863             Sequence< OUString > aLabels = m_bDataInColumns ? this->getRowDescriptions() : this->getColumnDescriptions();
 864             aResult.realloc( aLabels.getLength() );
 865             transform( aLabels.getConstArray(), aLabels.getConstArray() + aLabels.getLength(),
 866                        aResult.getArray(), CommonFunctors::makeAny< OUString >() );
 867         }
 868     }
 869     else
 870     {
 871         sal_Int32 nIndex = aRange.toInt32();
 872         if( nIndex >= 0 )
 873         {
 874             Sequence< double > aData;
 875             if( m_bDataInColumns )
 876                 aData = m_aInternalData.getColumnValues(nIndex);
 877             else
 878                 aData = m_aInternalData.getRowValues(nIndex);
 879             if( aData.getLength() )
 880             {
 881                 aResult.realloc( aData.getLength());
 882                 transform( aData.getConstArray(), aData.getConstArray() + aData.getLength(),
 883                            aResult.getArray(), CommonFunctors::makeAny< double >());
 884             }
 885         }
 886     }
 887
 888     return aResult;
 889 }
 890
 891 void SAL_CALL InternalDataProvider::setDataByRangeRepresentation(
 892     const OUString& aRange, const Sequence< uno::Any >& aNewData )
 893     throw (uno::RuntimeException)
 894 {
 895     vector< uno::Any > aNewVector( ContainerHelper::SequenceToVector(aNewData) );
 896     if( aRange.match( lcl_aLabelRangePrefix ) )
 897     {
 898         sal_uInt32 nIndex = aRange.copy( lcl_aLabelRangePrefix.getLength()).toInt32();
 899         if( m_bDataInColumns )
 900             m_aInternalData.setComplexColumnLabel( nIndex, aNewVector );
 901         else
 902             m_aInternalData.setComplexRowLabel( nIndex, aNewVector );
 903     }
 904     else if( aRange.match( lcl_aCategoriesPointRangeNamePrefix ) )
 905     {
 906         sal_Int32 nPointIndex = aRange.copy( lcl_aCategoriesLevelRangeNamePrefix.getLength()).toInt32();
 907         if( m_bDataInColumns )
 908             m_aInternalData.setComplexRowLabel( nPointIndex, aNewVector );
 909         else
 910             m_aInternalData.setComplexColumnLabel( nPointIndex, aNewVector );
 911     }
 912     else if( aRange.match( lcl_aCategoriesLevelRangeNamePrefix ) )
 913     {
 914         sal_Int32 nLevel = aRange.copy( lcl_aCategoriesLevelRangeNamePrefix.getLength()).toInt32();
 915         vector< vector< uno::Any > > aComplexCategories = m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels();
 916
 917         //ensure equal length
 918         if( aNewVector.size() > aComplexCategories.size() )
 919             aComplexCategories.resize( aNewVector.size() );
 920         else if( aNewVector.size() < aComplexCategories.size() )
 921             aNewVector.resize( aComplexCategories.size() );
 922
 923         transform( aComplexCategories.begin(), aComplexCategories.end(), aNewVector.begin(),
 924                    aComplexCategories.begin(), lcl_setAnyAtLevel(nLevel) );
 925
 926         if( m_bDataInColumns )
 927             m_aInternalData.setComplexRowLabels( aComplexCategories );
 928         else
 929             m_aInternalData.setComplexColumnLabels( aComplexCategories );
 930     }
 931     else if( aRange.equals( lcl_aCategoriesRangeName ) )
 932     {
 933         vector< vector< uno::Any > > aComplexCategories;
 934         aComplexCategories.resize( aNewVector.size() );
 935         transform( aComplexCategories.begin(), aComplexCategories.end(), aNewVector.begin(),
 936                             aComplexCategories.begin(), lcl_setAnyAtLevel(0) );
 937         if( m_bDataInColumns )
 938             m_aInternalData.setComplexRowLabels( aComplexCategories );
 939         else
 940             m_aInternalData.setComplexColumnLabels( aComplexCategories );
 941     }
 942     else
 943     {
 944         sal_Int32 nIndex = aRange.toInt32();
 945         if( nIndex>=0 )
 946         {
 947             vector< double > aNewDataVec;
 948             transform( aNewData.getConstArray(), aNewData.getConstArray() + aNewData.getLength(),
 949                        back_inserter( aNewDataVec ), CommonFunctors::AnyToDouble());
 950             if( m_bDataInColumns )
 951                 m_aInternalData.setColumnValues( nIndex, aNewDataVec );
 952             else
 953                 m_aInternalData.setRowValues( nIndex, aNewDataVec );
 954         }
 955     }
 956 }
 957
 958 void SAL_CALL InternalDataProvider::insertSequence( ::sal_Int32 nAfterIndex )
 959     throw (uno::RuntimeException)
 960 {
 961     if( m_bDataInColumns )
 962     {
 963         lcl_increaseMapReferences( nAfterIndex + 1, m_aInternalData.getColumnCount());
 964         m_aInternalData.insertColumn( nAfterIndex );
 965     }
 966     else
 967     {
 968         lcl_increaseMapReferences( nAfterIndex + 1, m_aInternalData.getRowCount());
 969         m_aInternalData.insertRow( nAfterIndex );
 970     }
 971 }
 972
 973 void SAL_CALL InternalDataProvider::deleteSequence( ::sal_Int32 nAtIndex )
 974     throw (uno::RuntimeException)
 975 {
 976     lcl_deleteMapReferences( OUString::valueOf( nAtIndex ));
 977     lcl_deleteMapReferences( lcl_aLabelRangePrefix + OUString::valueOf( nAtIndex ));
 978     if( m_bDataInColumns )
 979     {
 980         lcl_decreaseMapReferences( nAtIndex + 1, m_aInternalData.getColumnCount());
 981         m_aInternalData.deleteColumn( nAtIndex );
 982     }
 983     else
 984     {
 985         lcl_decreaseMapReferences( nAtIndex + 1, m_aInternalData.getRowCount());
 986         m_aInternalData.deleteRow( nAtIndex );
 987     }
 988 }
 989
 990 void SAL_CALL InternalDataProvider::appendSequence()
 991     throw (uno::RuntimeException)
 992 {
 993     if( m_bDataInColumns )
 994         m_aInternalData.appendColumn();
 995     else
 996         m_aInternalData.appendRow();
 997 }
 998
 999 void SAL_CALL InternalDataProvider::insertComplexCategoryLevel( sal_Int32 nLevel )
1000         throw (uno::RuntimeException)
1001 {
1002     OSL_ENSURE( nLevel> 0, "you can only insert category levels > 0" );//the first categories level cannot be deleted, check the calling code for error
1003     if( nLevel>0 )
1004     {
1005         vector< vector< uno::Any > > aComplexCategories = m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels();
1006         ::std::for_each( aComplexCategories.begin(), aComplexCategories.end(), lcl_insertAnyAtLevel(nLevel) );
1007         if( m_bDataInColumns )
1008             m_aInternalData.setComplexRowLabels( aComplexCategories );
1009         else
1010             m_aInternalData.setComplexColumnLabels( aComplexCategories );
1011
1012         tSequenceMapRange aRange( m_aSequenceMap.equal_range( lcl_aCategoriesRangeName ));
1013         ::std::for_each( aRange.first, aRange.second, lcl_setModified());
1014     }
1015 }
1016 void SAL_CALL InternalDataProvider::deleteComplexCategoryLevel( sal_Int32 nLevel )
1017         throw (uno::RuntimeException)
1018 {
1019     OSL_ENSURE( nLevel>0, "you can only delete category levels > 0" );//the first categories level cannot be deleted, check the calling code for error
1020     if( nLevel>0 )
1021     {
1022         vector< vector< uno::Any > > aComplexCategories = m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels();
1023         ::std::for_each( aComplexCategories.begin(), aComplexCategories.end(), lcl_removeAnyAtLevel(nLevel) );
1024         if( m_bDataInColumns )
1025             m_aInternalData.setComplexRowLabels( aComplexCategories );
1026         else
1027             m_aInternalData.setComplexColumnLabels( aComplexCategories );
1028
1029         tSequenceMapRange aRange( m_aSequenceMap.equal_range( lcl_aCategoriesRangeName ));
1030         ::std::for_each( aRange.first, aRange.second, lcl_setModified());
1031     }
1032 }
1033
1034 void SAL_CALL InternalDataProvider::insertDataPointForAllSequences( ::sal_Int32 nAfterIndex )
1035     throw (uno::RuntimeException)
1036 {
1037     sal_Int32 nMaxRep = 0;
1038     if( m_bDataInColumns )
1039     {
1040         m_aInternalData.insertRow( nAfterIndex );
1041         nMaxRep = m_aInternalData.getColumnCount();
1042     }
1043     else
1044     {
1045         m_aInternalData.insertColumn( nAfterIndex );
1046         nMaxRep = m_aInternalData.getRowCount();
1047     }
1048
1049     // notify change to all affected ranges
1050     tSequenceMap::const_iterator aBegin( m_aSequenceMap.lower_bound( C2U("0")));
1051     tSequenceMap::const_iterator aEnd( m_aSequenceMap.upper_bound( OUString::valueOf( nMaxRep )));
1052     ::std::for_each( aBegin, aEnd, lcl_setModified());
1053
1054     tSequenceMapRange aRange( m_aSequenceMap.equal_range( lcl_aCategoriesRangeName ));
1055     ::std::for_each( aRange.first, aRange.second, lcl_setModified());
1056 }
1057
1058 void SAL_CALL InternalDataProvider::deleteDataPointForAllSequences( ::sal_Int32 nAtIndex )
1059     throw (uno::RuntimeException)
1060 {
1061     sal_Int32 nMaxRep = 0;
1062     if( m_bDataInColumns )
1063     {
1064         m_aInternalData.deleteRow( nAtIndex );
1065         nMaxRep = m_aInternalData.getColumnCount();
1066     }
1067     else
1068     {
1069         m_aInternalData.deleteColumn( nAtIndex );
1070         nMaxRep = m_aInternalData.getRowCount();
1071     }
1072
1073     // notify change to all affected ranges
1074     tSequenceMap::const_iterator aBegin( m_aSequenceMap.lower_bound( C2U("0")));
1075     tSequenceMap::const_iterator aEnd( m_aSequenceMap.upper_bound( OUString::valueOf( nMaxRep )));
1076     ::std::for_each( aBegin, aEnd, lcl_setModified());
1077
1078     tSequenceMapRange aRange( m_aSequenceMap.equal_range( lcl_aCategoriesRangeName ));
1079     ::std::for_each( aRange.first, aRange.second, lcl_setModified());
1080 }
1081
1082 void SAL_CALL InternalDataProvider::swapDataPointWithNextOneForAllSequences( ::sal_Int32 nAtIndex )
1083     throw (uno::RuntimeException)
1084 {
1085     if( m_bDataInColumns )
1086         m_aInternalData.swapRowWithNext( nAtIndex );
1087     else
1088         m_aInternalData.swapColumnWithNext( nAtIndex );
1089     sal_Int32 nMaxRep = (m_bDataInColumns
1090                          ? m_aInternalData.getColumnCount()
1091                          : m_aInternalData.getRowCount());
1092
1093     // notify change to all affected ranges
1094     tSequenceMap::const_iterator aBegin( m_aSequenceMap.lower_bound( C2U("0")));
1095     tSequenceMap::const_iterator aEnd( m_aSequenceMap.upper_bound( OUString::valueOf( nMaxRep )));
1096     ::std::for_each( aBegin, aEnd, lcl_setModified());
1097
1098     tSequenceMapRange aRange( m_aSequenceMap.equal_range( lcl_aCategoriesRangeName ));
1099     ::std::for_each( aRange.first, aRange.second, lcl_setModified());
1100 }
1101
1102 void SAL_CALL InternalDataProvider::registerDataSequenceForChanges( const Reference< chart2::data::XDataSequence >& xSeq )
1103     throw (uno::RuntimeException)
1104 {
1105     if( xSeq.is())
1106         lcl_addDataSequenceToMap( xSeq->getSourceRangeRepresentation(), xSeq );
1107 }
1108
1109
1110 // ____ XRangeXMLConversion ____
1111 OUString SAL_CALL InternalDataProvider::convertRangeToXML( const OUString& aRangeRepresentation )
1112     throw (lang::IllegalArgumentException,
1113            uno::RuntimeException)
1114 {
1115     XMLRangeHelper::CellRange aRange;
1116     aRange.aTableName = OUString(RTL_CONSTASCII_USTRINGPARAM("local-table"));
1117
1118     // attention: this data provider has the limitation that it stores
1119     // internally if data comes from columns or rows. It is intended for
1120     // creating only one used data source.
1121     // @todo: add this information in the range representation strings
1122     if( aRangeRepresentation.match( lcl_aCategoriesRangeName ))
1123     {
1124         OSL_ASSERT( aRangeRepresentation.equals( lcl_aCategoriesRangeName ) );//it is not expected nor implmented that only parts of the categories are really requested
1125         aRange.aUpperLeft.bIsEmpty = false;
1126         if( m_bDataInColumns )
1127         {
1128             aRange.aUpperLeft.nColumn = 0;
1129             aRange.aUpperLeft.nRow = 1;
1130             aRange.aLowerRight = aRange.aUpperLeft;
1131             aRange.aLowerRight.nRow = m_aInternalData.getRowCount();
1132         }
1133         else
1134         {
1135             aRange.aUpperLeft.nColumn = 1;
1136             aRange.aUpperLeft.nRow = 0;
1137             aRange.aLowerRight = aRange.aUpperLeft;
1138             aRange.aLowerRight.nColumn = m_aInternalData.getColumnCount();
1139         }
1140     }
1141     else if( aRangeRepresentation.match( lcl_aLabelRangePrefix ))
1142     {
1143         sal_Int32 nIndex = aRangeRepresentation.copy( lcl_aLabelRangePrefix.getLength()).toInt32();
1144         aRange.aUpperLeft.bIsEmpty = false;
1145         aRange.aLowerRight.bIsEmpty = true;
1146         if( m_bDataInColumns )
1147         {
1148             aRange.aUpperLeft.nColumn = nIndex + 1;
1149             aRange.aUpperLeft.nRow = 0;
1150         }
1151         else
1152         {
1153             aRange.aUpperLeft.nColumn = 0;
1154             aRange.aUpperLeft.nRow = nIndex + 1;
1155         }
1156     }
1157     else if( aRangeRepresentation.equals( lcl_aCompleteRange ))
1158     {
1159         aRange.aUpperLeft.bIsEmpty = false;
1160         aRange.aLowerRight.bIsEmpty = false;
1161         aRange.aUpperLeft.nColumn = 0;
1162         aRange.aUpperLeft.nRow = 0;
1163         aRange.aLowerRight.nColumn = m_aInternalData.getColumnCount();
1164         aRange.aLowerRight.nRow = m_aInternalData.getRowCount();
1165     }
1166     else
1167     {
1168         sal_Int32 nIndex = aRangeRepresentation.toInt32();
1169         aRange.aUpperLeft.bIsEmpty = false;
1170         if( m_bDataInColumns )
1171         {
1172             aRange.aUpperLeft.nColumn = nIndex + 1;
1173             aRange.aUpperLeft.nRow = 1;
1174             aRange.aLowerRight = aRange.aUpperLeft;
1175             aRange.aLowerRight.nRow = m_aInternalData.getRowCount();
1176         }
1177         else
1178         {
1179             aRange.aUpperLeft.nColumn = 1;
1180             aRange.aUpperLeft.nRow = nIndex + 1;
1181             aRange.aLowerRight = aRange.aUpperLeft;
1182             aRange.aLowerRight.nColumn = m_aInternalData.getColumnCount();
1183         }
1184     }
1185
1186     return XMLRangeHelper::getXMLStringFromCellRange( aRange );
1187 }
1188
1189 OUString SAL_CALL InternalDataProvider::convertRangeFromXML( const OUString& aXMLRange )
1190     throw (lang::IllegalArgumentException,
1191            uno::RuntimeException)
1192 {
1193     XMLRangeHelper::CellRange aRange( XMLRangeHelper::getCellRangeFromXMLString( aXMLRange ));
1194     if( aRange.aUpperLeft.bIsEmpty )
1195     {
1196         OSL_ENSURE( aRange.aLowerRight.bIsEmpty, "Weird Range" );
1197         return OUString();
1198     }
1199
1200     // "all"
1201     if( !aRange.aLowerRight.bIsEmpty &&
1202         ( aRange.aUpperLeft.nColumn != aRange.aLowerRight.nColumn ) &&
1203         ( aRange.aUpperLeft.nRow != aRange.aLowerRight.nRow ) )
1204         return lcl_aCompleteRange;
1205
1206     // attention: this data provider has the limitation that it stores
1207     // internally if data comes from columns or rows. It is intended for
1208     // creating only one used data source.
1209     // @todo: add this information in the range representation strings
1210
1211     // data in columns
1212     if( m_bDataInColumns )
1213     {
1214         if( aRange.aUpperLeft.nColumn == 0 )
1215             return lcl_aCategoriesRangeName;
1216         if( aRange.aUpperLeft.nRow == 0 )
1217             return lcl_aLabelRangePrefix + OUString::valueOf( aRange.aUpperLeft.nColumn - 1 );
1218
1219         return OUString::valueOf( aRange.aUpperLeft.nColumn - 1 );
1220     }
1221
1222     // data in rows
1223     if( aRange.aUpperLeft.nRow == 0 )
1224         return lcl_aCategoriesRangeName;
1225     if( aRange.aUpperLeft.nColumn == 0 )
1226         return lcl_aLabelRangePrefix + OUString::valueOf( aRange.aUpperLeft.nRow - 1 );
1227
1228     return OUString::valueOf( aRange.aUpperLeft.nRow - 1 );
1229 }
1230
1231 namespace
1232 {
1233
1234 template< class Type >
1235 Sequence< Sequence< Type > > lcl_convertVectorVectorToSequenceSequence( const vector< vector< Type > >& rIn )
1236 {
1237     Sequence< Sequence< Type > > aRet;
1238     sal_Int32 nOuterCount = rIn.size();
1239     if( nOuterCount )
1240     {
1241         aRet.realloc(nOuterCount);
1242         for( sal_Int32 nN=0; nN<nOuterCount; nN++)
1243             aRet[nN]= ContainerHelper::ContainerToSequence( rIn[nN] );
1244     }
1245     return aRet;
1246 }
1247
1248 template< class Type >
1249 vector< vector< Type > > lcl_convertSequenceSequenceToVectorVector( const Sequence< Sequence< Type > >& rIn )
1250 {
1251     vector< vector< Type > > aRet;
1252     sal_Int32 nOuterCount = rIn.getLength();
1253     if( nOuterCount )
1254     {
1255         aRet.resize(nOuterCount);
1256         for( sal_Int32 nN=0; nN<nOuterCount; nN++)
1257             aRet[nN]= ContainerHelper::SequenceToVector( rIn[nN] );
1258     }
1259     return aRet;
1260 }
1261
1262 Sequence< Sequence< OUString > > lcl_convertComplexAnyVectorToStringSequence( const vector< vector< uno::Any > >& rIn )
1263 {
1264     Sequence< Sequence< OUString > > aRet;
1265     sal_Int32 nOuterCount = rIn.size();
1266     if( nOuterCount )
1267     {
1268         aRet.realloc(nOuterCount);
1269         for( sal_Int32 nN=0; nN<nOuterCount; nN++)
1270             aRet[nN]= lcl_AnyToStringSequence( ContainerHelper::ContainerToSequence( rIn[nN] ) );
1271     }
1272     return aRet;
1273 }
1274
1275 vector< vector< uno::Any > > lcl_convertComplexStringSequenceToAnyVector( const Sequence< Sequence< OUString > >& rIn )
1276 {
1277     vector< vector< uno::Any > > aRet;
1278     sal_Int32 nOuterCount = rIn.getLength();
1279     for( sal_Int32 nN=0; nN<nOuterCount; nN++)
1280         aRet.push_back( ContainerHelper::SequenceToVector( lcl_StringToAnySequence( rIn[nN] ) ) );
1281     return aRet;
1282 }
1283
1284 class SplitCategoriesProvider_ForComplexDescriptions : public SplitCategoriesProvider
1285 {
1286 public:
1287
1288     explicit SplitCategoriesProvider_ForComplexDescriptions( const ::std::vector< ::std::vector< uno::Any > >& rComplexDescriptions )
1289         : m_rComplexDescriptions( rComplexDescriptions )
1290     {}
1291     virtual ~SplitCategoriesProvider_ForComplexDescriptions()
1292     {}
1293
1294     virtual sal_Int32 getLevelCount() const;
1295     virtual uno::Sequence< rtl::OUString > getStringsForLevel( sal_Int32 nIndex ) const;
1296
1297 private:
1298     const ::std::vector< ::std::vector< uno::Any > >& m_rComplexDescriptions;
1299 };
1300
1301 sal_Int32 SplitCategoriesProvider_ForComplexDescriptions::getLevelCount() const
1302 {
1303     return lcl_getInnerLevelCount( m_rComplexDescriptions );
1304 }
1305 uno::Sequence< rtl::OUString > SplitCategoriesProvider_ForComplexDescriptions::getStringsForLevel( sal_Int32 nLevel ) const
1306 {
1307     uno::Sequence< rtl::OUString > aResult;
1308     if( nLevel < lcl_getInnerLevelCount( m_rComplexDescriptions ) )
1309     {
1310         aResult.realloc( m_rComplexDescriptions.size() );
1311         transform( m_rComplexDescriptions.begin(), m_rComplexDescriptions.end(),
1312                    aResult.getArray(), lcl_getStringFromLevelVector(nLevel) );
1313     }
1314     return aResult;
1315 }
1316
1317 }//anonymous namespace
1318
1319 // ____ XDateCategories ____
1320 Sequence< double > SAL_CALL InternalDataProvider::getDateCategories() throw (uno::RuntimeException)
1321 {
1322     double fNan = InternalDataProvider::getNotANumber();
1323     double fValue = fNan;
1324     vector< vector< uno::Any > > aCategories( m_bDataInColumns ? m_aInternalData.getComplexRowLabels() : m_aInternalData.getComplexColumnLabels());
1325     sal_Int32 nCount = aCategories.size();
1326     Sequence< double > aDoubles( nCount );
1327     vector< vector< uno::Any > >::iterator aIt( aCategories.begin() );
1328     vector< vector< uno::Any > >::const_iterator aEnd( aCategories.end() );
1329     for(sal_Int32 nN=0; nN<nCount && aIt!=aEnd; ++nN, ++aIt )
1330     {
1331         if( !( !aIt->empty() && ((*aIt)[0]>>=fValue) ) )
1332             fValue = fNan;
1333         aDoubles[nN]=fValue;
1334     }
1335     return aDoubles;
1336 }
1337
1338 void SAL_CALL InternalDataProvider::setDateCategories( const Sequence< double >& rDates ) throw (uno::RuntimeException)
1339 {
1340     sal_Int32 nCount = rDates.getLength();
1341     vector< vector< uno::Any > > aNewCategories;
1342     aNewCategories.reserve(nCount);
1343     vector< uno::Any > aSingleLabel(1);
1344
1345     for(sal_Int32 nN=0; nN<nCount; ++nN )
1346     {
1347         aSingleLabel[0]=uno::makeAny(rDates[nN]);
1348         aNewCategories.push_back(aSingleLabel);
1349     }
1350
1351     if( m_bDataInColumns )
1352         m_aInternalData.setComplexRowLabels( aNewCategories );
1353     else
1354         m_aInternalData.setComplexColumnLabels( aNewCategories );
1355 }
1356
1357 // ____ XAnyDescriptionAccess ____
1358 Sequence< Sequence< uno::Any > > SAL_CALL InternalDataProvider::getAnyRowDescriptions() throw (uno::RuntimeException)
1359 {
1360     return lcl_convertVectorVectorToSequenceSequence( m_aInternalData.getComplexRowLabels() );
1361 }
1362 void SAL_CALL InternalDataProvider::setAnyRowDescriptions( const Sequence< Sequence< uno::Any > >& aRowDescriptions ) throw (uno::RuntimeException)
1363 {
1364     m_aInternalData.setComplexRowLabels( lcl_convertSequenceSequenceToVectorVector( aRowDescriptions ) );
1365 }
1366 Sequence< Sequence< uno::Any > > SAL_CALL InternalDataProvider::getAnyColumnDescriptions() throw (uno::RuntimeException)
1367 {
1368     return lcl_convertVectorVectorToSequenceSequence( m_aInternalData.getComplexColumnLabels() );
1369 }
1370 void SAL_CALL InternalDataProvider::setAnyColumnDescriptions( const Sequence< Sequence< uno::Any > >& aColumnDescriptions ) throw (uno::RuntimeException)
1371 {
1372     m_aInternalData.setComplexColumnLabels( lcl_convertSequenceSequenceToVectorVector( aColumnDescriptions ) );
1373 }
1374
1375 // ____ XComplexDescriptionAccess ____
1376 Sequence< Sequence< OUString > > SAL_CALL InternalDataProvider::getComplexRowDescriptions() throw (uno::RuntimeException)
1377 {
1378     return lcl_convertComplexAnyVectorToStringSequence( m_aInternalData.getComplexRowLabels() );
1379 }
1380 void SAL_CALL InternalDataProvider::setComplexRowDescriptions( const Sequence< Sequence< ::rtl::OUString > >& aRowDescriptions ) throw (uno::RuntimeException)
1381 {
1382     m_aInternalData.setComplexRowLabels( lcl_convertComplexStringSequenceToAnyVector(aRowDescriptions) );
1383 }
1384 Sequence< Sequence< ::rtl::OUString > > SAL_CALL InternalDataProvider::getComplexColumnDescriptions() throw (uno::RuntimeException)
1385 {
1386     return lcl_convertComplexAnyVectorToStringSequence( m_aInternalData.getComplexColumnLabels() );
1387 }
1388 void SAL_CALL InternalDataProvider::setComplexColumnDescriptions( const Sequence< Sequence< ::rtl::OUString > >& aColumnDescriptions ) throw (uno::RuntimeException)
1389 {
1390     m_aInternalData.setComplexColumnLabels( lcl_convertComplexStringSequenceToAnyVector(aColumnDescriptions) );
1391 }
1392
1393 // ____ XChartDataArray ____
1394 Sequence< Sequence< double > > SAL_CALL InternalDataProvider::getData()
1395     throw (uno::RuntimeException)
1396 {
1397     return m_aInternalData.getData();
1398 }
1399
1400 void SAL_CALL InternalDataProvider::setData( const Sequence< Sequence< double > >& rDataInRows )
1401     throw (uno::RuntimeException)
1402 {
1403     return m_aInternalData.setData( rDataInRows );
1404 }
1405
1406 void SAL_CALL InternalDataProvider::setRowDescriptions( const Sequence< OUString >& aRowDescriptions )
1407     throw (uno::RuntimeException)
1408 {
1409     vector< vector< uno::Any > > aComplexDescriptions( aRowDescriptions.getLength() );
1410     transform( aComplexDescriptions.begin(), aComplexDescriptions.end(), aRowDescriptions.getConstArray(),
1411                aComplexDescriptions.begin(), lcl_setAnyAtLevelFromStringSequence(0) );
1412     m_aInternalData.setComplexRowLabels( aComplexDescriptions );
1413 }
1414
1415 void SAL_CALL InternalDataProvider::setColumnDescriptions( const Sequence< OUString >& aColumnDescriptions )
1416     throw (uno::RuntimeException)
1417 {
1418     vector< vector< uno::Any > > aComplexDescriptions( aColumnDescriptions.getLength() );
1419     transform( aComplexDescriptions.begin(), aComplexDescriptions.end(), aColumnDescriptions.getConstArray(),
1420                aComplexDescriptions.begin(), lcl_setAnyAtLevelFromStringSequence(0) );
1421     m_aInternalData.setComplexColumnLabels( aComplexDescriptions );
1422 }
1423
1424 Sequence< OUString > SAL_CALL InternalDataProvider::getRowDescriptions()
1425     throw (uno::RuntimeException)
1426 {
1427     vector< vector< uno::Any > > aComplexLabels( m_aInternalData.getComplexRowLabels() );
1428     SplitCategoriesProvider_ForComplexDescriptions aProvider( aComplexLabels );
1429     return ExplicitCategoriesProvider::getExplicitSimpleCategories( aProvider );
1430 }
1431
1432 Sequence< OUString > SAL_CALL InternalDataProvider::getColumnDescriptions()
1433     throw (uno::RuntimeException)
1434 {
1435     vector< vector< uno::Any > > aComplexLabels( m_aInternalData.getComplexColumnLabels() );
1436     SplitCategoriesProvider_ForComplexDescriptions aProvider( aComplexLabels );
1437     return ExplicitCategoriesProvider::getExplicitSimpleCategories( aProvider );
1438 }
1439
1440 // ____ XChartData (base of XChartDataArray) ____
1441 void SAL_CALL InternalDataProvider::addChartDataChangeEventListener(
1442     const Reference< ::com::sun::star::chart::XChartDataChangeEventListener >& )
1443     throw (uno::RuntimeException)
1444 {
1445 }
1446
1447 void SAL_CALL InternalDataProvider::removeChartDataChangeEventListener(
1448     const Reference< ::com::sun::star::chart::XChartDataChangeEventListener >& )
1449     throw (uno::RuntimeException)
1450 {
1451 }
1452
1453 double SAL_CALL InternalDataProvider::getNotANumber()
1454     throw (uno::RuntimeException)
1455 {
1456     double fNan;
1457     ::rtl::math::setNan( & fNan );
1458     return fNan;
1459 }
1460
1461 ::sal_Bool SAL_CALL InternalDataProvider::isNotANumber( double nNumber )
1462     throw (uno::RuntimeException)
1463 {
1464     return ::rtl::math::isNan( nNumber )
1465         || ::rtl::math::isInf( nNumber );
1466 }
1467 // lang::XInitialization:
1468 void SAL_CALL InternalDataProvider::initialize(const uno::Sequence< uno::Any > & _aArguments) throw (uno::RuntimeException, uno::Exception)
1469 {
1470     comphelper::SequenceAsHashMap aArgs(_aArguments);
1471     if ( aArgs.getUnpackedValueOrDefault(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CreateDefaultData")),sal_False) )
1472         createDefaultData();
1473 }
1474 // ____ XCloneable ____
1475 Reference< util::XCloneable > SAL_CALL InternalDataProvider::createClone()
1476     throw (uno::RuntimeException)
1477 {
1478     return Reference< util::XCloneable >( new InternalDataProvider( *this ));
1479 }
1480
1481
1482 // ================================================================================
1483
1484 Sequence< OUString > InternalDataProvider::getSupportedServiceNames_Static()
1485 {
1486     Sequence< OUString > aServices( 1 );
1487     aServices[ 0 ] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.data.DataProvider" ));
1488     return aServices;
1489 }
1490
1491 // ================================================================================
1492
1493 APPHELPER_XSERVICEINFO_IMPL( InternalDataProvider, lcl_aServiceName );
1494
1495 } //  namespace chart
1496
1497 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */