chart2/source/controller/chartapiwrapper/ChartDataWrapper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "ChartDataWrapper.hxx"
  21 #include <DiagramHelper.hxx>
  22 #include <DataSourceHelper.hxx>
  23 #include <ChartModelHelper.hxx>
  24 #include <ControllerLockGuard.hxx>
  25 #include "Chart2ModelContact.hxx"
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <com/sun/star/chart2/XChartDocument.hpp>
  28 #include <com/sun/star/chart/XChartDocument.hpp>
  29
  30 #include <float.h>
  31 #include <rtl/math.hxx>
  32 #include <osl/diagnose.h>
  33
  34 using namespace ::com::sun::star;
  35 using ::com::sun::star::uno::Reference;
  36 using ::com::sun::star::uno::Sequence;
  37 using ::com::sun::star::chart2::XAnyDescriptionAccess;
  38 using ::com::sun::star::chart::XComplexDescriptionAccess;
  39 using ::com::sun::star::chart::XChartData;
  40 using ::com::sun::star::chart::XChartDataArray;
  41 using ::com::sun::star::chart::XDateCategories;
  42
  43 namespace
  44 {
  45
  46 uno::Sequence< uno::Sequence< double > > lcl_getNANInsteadDBL_MIN( const uno::Sequence< uno::Sequence< double > >& rData )
  47 {
  48     uno::Sequence< uno::Sequence< double > > aRet;
  49     const sal_Int32 nOuterSize = rData.getLength();
  50     aRet.realloc( nOuterSize );
  51     for( sal_Int32 nOuter=0; nOuter<nOuterSize; ++nOuter )
  52     {
  53         sal_Int32 nInnerSize = rData[nOuter].getLength();
  54         aRet[nOuter].realloc( nInnerSize );
  55         for( sal_Int32 nInner=0; nInner<nInnerSize; ++nInner )
  56         {
  57             aRet[nOuter][nInner] = rData[nOuter][nInner];
  58             double& rValue = aRet[nOuter][nInner];
  59             if( rValue == DBL_MIN )
  60                 ::rtl::math::setNan( &rValue );
  61         }
  62     }
  63     return aRet;
  64 }
  65
  66 uno::Sequence< uno::Sequence< double > > lcl_getDBL_MINInsteadNAN( const uno::Sequence< uno::Sequence< double > >& rData )
  67 {
  68     uno::Sequence< uno::Sequence< double > > aRet;
  69     const sal_Int32 nOuterSize = rData.getLength();
  70     aRet.realloc( nOuterSize );
  71     for( sal_Int32 nOuter=0; nOuter<nOuterSize; ++nOuter )
  72     {
  73         sal_Int32 nInnerSize = rData[nOuter].getLength();
  74         aRet[nOuter].realloc( nInnerSize );
  75         for( sal_Int32 nInner=0; nInner<nInnerSize; ++nInner )
  76         {
  77             aRet[nOuter][nInner] = rData[nOuter][nInner];
  78             double& rValue = aRet[nOuter][nInner];
  79             if( ::rtl::math::isNan( rValue ) )
  80                 rValue = DBL_MIN;
  81         }
  82     }
  83     return aRet;
  84 }
  85
  86 } // anonymous namespace
  87
  88 namespace chart
  89 {
  90 namespace wrapper
  91 {
  92
  93 struct lcl_Operator
  94 {
  95     lcl_Operator()
  96     {
  97     }
  98     virtual ~lcl_Operator()
  99     {
 100     }
 101     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) = 0;
 102
 103     virtual bool setsCategories( bool /*bDataInColumns*/ )
 104     {
 105         return false;
 106     }
 107 };
 108
 109 struct lcl_AllOperator : public lcl_Operator
 110 {
 111     explicit lcl_AllOperator( const Reference< XChartData >& xDataToApply )
 112         : lcl_Operator()
 113         , m_xDataToApply( xDataToApply )
 114     {
 115     }
 116
 117     virtual bool setsCategories( bool /*bDataInColumns*/ ) override
 118     {
 119         return true;
 120     }
 121
 122     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 123     {
 124         if( !xDataAccess.is() )
 125             return;
 126
 127         Reference< XAnyDescriptionAccess > xNewAny( m_xDataToApply, uno::UNO_QUERY );
 128         Reference< XComplexDescriptionAccess > xNewComplex( m_xDataToApply, uno::UNO_QUERY );
 129         if( xNewAny.is() )
 130         {
 131             xDataAccess->setData( xNewAny->getData() );
 132             xDataAccess->setComplexRowDescriptions( xNewAny->getComplexRowDescriptions() );
 133             xDataAccess->setComplexColumnDescriptions( xNewAny->getComplexColumnDescriptions() );
 134         }
 135         else if( xNewComplex.is() )
 136         {
 137             xDataAccess->setData( xNewComplex->getData() );
 138             xDataAccess->setComplexRowDescriptions( xNewComplex->getComplexRowDescriptions() );
 139             xDataAccess->setComplexColumnDescriptions( xNewComplex->getComplexColumnDescriptions() );
 140         }
 141         else
 142         {
 143             Reference< XChartDataArray > xNew( m_xDataToApply, uno::UNO_QUERY );
 144             if( xNew.is() )
 145             {
 146                 xDataAccess->setData( xNew->getData() );
 147                 xDataAccess->setRowDescriptions( xNew->getRowDescriptions() );
 148                 xDataAccess->setColumnDescriptions( xNew->getColumnDescriptions() );
 149             }
 150         }
 151     }
 152
 153     Reference< XChartData > m_xDataToApply;
 154 };
 155
 156 struct lcl_DataOperator : public lcl_Operator
 157 {
 158     explicit lcl_DataOperator( const Sequence< Sequence< double > >& rData )
 159         : lcl_Operator()
 160         , m_rData( rData )
 161     {
 162     }
 163
 164     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 165     {
 166         if( xDataAccess.is() )
 167             xDataAccess->setData( lcl_getNANInsteadDBL_MIN( m_rData ) );
 168     }
 169
 170     const Sequence< Sequence< double > >& m_rData;
 171 };
 172
 173 struct lcl_RowDescriptionsOperator : public lcl_Operator
 174 {
 175     lcl_RowDescriptionsOperator( const Sequence< OUString >& rRowDescriptions
 176         , const Reference< chart2::XChartDocument >& xChartDoc )
 177         : lcl_Operator()
 178         , m_rRowDescriptions( rRowDescriptions )
 179         , m_xChartDoc(xChartDoc)
 180         , m_bDataInColumns(true)
 181     {
 182     }
 183
 184     virtual bool setsCategories( bool bDataInColumns ) override
 185     {
 186         m_bDataInColumns = bDataInColumns;
 187         return bDataInColumns;
 188     }
 189
 190     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 191     {
 192         if( xDataAccess.is() )
 193         {
 194             xDataAccess->setRowDescriptions( m_rRowDescriptions );
 195             if( m_bDataInColumns )
 196                 DiagramHelper::switchToTextCategories( m_xChartDoc );
 197         }
 198     }
 199
 200     const Sequence< OUString >& m_rRowDescriptions;
 201     Reference< chart2::XChartDocument > m_xChartDoc;
 202     bool m_bDataInColumns;
 203 };
 204
 205 struct lcl_ComplexRowDescriptionsOperator : public lcl_Operator
 206 {
 207     lcl_ComplexRowDescriptionsOperator( const Sequence< Sequence< OUString > >& rComplexRowDescriptions
 208         , const Reference< chart2::XChartDocument >& xChartDoc )
 209         : lcl_Operator()
 210         , m_rComplexRowDescriptions( rComplexRowDescriptions )
 211         , m_xChartDoc(xChartDoc)
 212         , m_bDataInColumns(true)
 213     {
 214     }
 215
 216     virtual bool setsCategories( bool bDataInColumns ) override
 217     {
 218         m_bDataInColumns = bDataInColumns;
 219         return bDataInColumns;
 220     }
 221
 222     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 223     {
 224         if( xDataAccess.is() )
 225         {
 226             xDataAccess->setComplexRowDescriptions( m_rComplexRowDescriptions );
 227             if( m_bDataInColumns )
 228                 DiagramHelper::switchToTextCategories( m_xChartDoc );
 229         }
 230     }
 231
 232     const Sequence< Sequence< OUString > >& m_rComplexRowDescriptions;
 233     Reference< chart2::XChartDocument > m_xChartDoc;
 234     bool m_bDataInColumns;
 235 };
 236
 237 struct lcl_AnyRowDescriptionsOperator : public lcl_Operator
 238 {
 239     explicit lcl_AnyRowDescriptionsOperator( const Sequence< Sequence< uno::Any > >& rAnyRowDescriptions )
 240         : lcl_Operator()
 241         , m_rAnyRowDescriptions( rAnyRowDescriptions )
 242     {
 243     }
 244
 245     virtual bool setsCategories( bool bDataInColumns ) override
 246     {
 247         return bDataInColumns;
 248     }
 249
 250     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 251     {
 252         if( xDataAccess.is() )
 253             xDataAccess->setAnyRowDescriptions( m_rAnyRowDescriptions );
 254     }
 255
 256     const Sequence< Sequence< uno::Any > >& m_rAnyRowDescriptions;
 257 };
 258
 259 struct lcl_ColumnDescriptionsOperator : public lcl_Operator
 260 {
 261     lcl_ColumnDescriptionsOperator( const Sequence< OUString >& rColumnDescriptions
 262         , const Reference< chart2::XChartDocument >& xChartDoc )
 263         : lcl_Operator()
 264         , m_rColumnDescriptions( rColumnDescriptions )
 265         , m_xChartDoc(xChartDoc)
 266         , m_bDataInColumns(true)
 267     {
 268     }
 269
 270     virtual bool setsCategories( bool bDataInColumns ) override
 271     {
 272         m_bDataInColumns = bDataInColumns;
 273         return !bDataInColumns;
 274     }
 275
 276     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 277     {
 278         if( xDataAccess.is() )
 279         {
 280             xDataAccess->setColumnDescriptions( m_rColumnDescriptions );
 281             if( !m_bDataInColumns )
 282                 DiagramHelper::switchToTextCategories( m_xChartDoc );
 283         }
 284     }
 285
 286     const Sequence< OUString >& m_rColumnDescriptions;
 287     Reference< chart2::XChartDocument > m_xChartDoc;
 288     bool m_bDataInColumns;
 289 };
 290
 291 struct lcl_ComplexColumnDescriptionsOperator : public lcl_Operator
 292 {
 293     lcl_ComplexColumnDescriptionsOperator( const Sequence< Sequence< OUString > >& rComplexColumnDescriptions
 294         , const Reference< chart2::XChartDocument >& xChartDoc )
 295         : lcl_Operator()
 296         , m_rComplexColumnDescriptions( rComplexColumnDescriptions )
 297         , m_xChartDoc(xChartDoc)
 298         , m_bDataInColumns(true)
 299     {
 300     }
 301
 302     virtual bool setsCategories( bool bDataInColumns ) override
 303     {
 304         m_bDataInColumns = bDataInColumns;
 305         return !bDataInColumns;
 306     }
 307
 308     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 309     {
 310         if( xDataAccess.is() )
 311         {
 312             xDataAccess->setComplexColumnDescriptions( m_rComplexColumnDescriptions );
 313             if( !m_bDataInColumns )
 314                 DiagramHelper::switchToTextCategories( m_xChartDoc );
 315         }
 316     }
 317
 318     const Sequence< Sequence< OUString > >& m_rComplexColumnDescriptions;
 319     Reference< chart2::XChartDocument > m_xChartDoc;
 320     bool m_bDataInColumns;
 321 };
 322
 323 struct lcl_AnyColumnDescriptionsOperator : public lcl_Operator
 324 {
 325     explicit lcl_AnyColumnDescriptionsOperator( const Sequence< Sequence< uno::Any > >& rAnyColumnDescriptions )
 326         : lcl_Operator()
 327         , m_rAnyColumnDescriptions( rAnyColumnDescriptions )
 328     {
 329     }
 330
 331     virtual bool setsCategories( bool bDataInColumns ) override
 332     {
 333         return bDataInColumns;
 334     }
 335
 336     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 337     {
 338         if( xDataAccess.is() )
 339             xDataAccess->setAnyColumnDescriptions( m_rAnyColumnDescriptions );
 340     }
 341
 342     const Sequence< Sequence< uno::Any > >& m_rAnyColumnDescriptions;
 343 };
 344
 345 struct lcl_DateCategoriesOperator : public lcl_Operator
 346 {
 347     explicit lcl_DateCategoriesOperator( const Sequence< double >& rDates )
 348         : lcl_Operator()
 349         , m_rDates( rDates )
 350     {
 351     }
 352
 353     virtual bool setsCategories( bool /*bDataInColumns*/ ) override
 354     {
 355         return true;
 356     }
 357
 358     virtual void apply( const Reference< XAnyDescriptionAccess >& xDataAccess ) override
 359     {
 360         Reference< XDateCategories > xDateCategories( xDataAccess, uno::UNO_QUERY );
 361         if( xDateCategories.is() )
 362             xDateCategories->setDateCategories( m_rDates );
 363     }
 364
 365     const Sequence< double >& m_rDates;
 366 };
 367
 368 ChartDataWrapper::ChartDataWrapper(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 369     : m_spChart2ModelContact(spChart2ModelContact)
 370     , m_aEventListenerContainer(m_aMutex)
 371 {
 372     osl_atomic_increment( &m_refCount );
 373     initDataAccess();
 374     osl_atomic_decrement( &m_refCount );
 375 }
 376
 377 ChartDataWrapper::ChartDataWrapper( const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 378                                     const Reference< XChartData >& xNewData ) :
 379         m_spChart2ModelContact( spChart2ModelContact ),
 380         m_aEventListenerContainer( m_aMutex )
 381 {
 382     osl_atomic_increment( &m_refCount );
 383     lcl_AllOperator aOperator( xNewData );
 384     applyData( aOperator );
 385     osl_atomic_decrement( &m_refCount );
 386 }
 387
 388 ChartDataWrapper::~ChartDataWrapper()
 389 {
 390     // @todo: implement XComponent and call this in dispose().  In the DTOR the
 391     // ref-count is 0, thus creating a stack reference to this calls the DTOR at
 392     // the end of the block recursively
 393 //     uno::Reference< uno::XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) );
 394 //     m_aEventListenerContainer.disposeAndClear( lang::EventObject( xSource ) );
 395 }
 396
 397 // ____ XChartDataArray (read)____
 398 Sequence< Sequence< double > > SAL_CALL ChartDataWrapper::getData()
 399 {
 400     initDataAccess();
 401     if( m_xDataAccess.is() )
 402         return lcl_getDBL_MINInsteadNAN( m_xDataAccess->getData() );
 403     return Sequence< Sequence< double > >();
 404 }
 405 Sequence< OUString > SAL_CALL ChartDataWrapper::getRowDescriptions()
 406 {
 407     initDataAccess();
 408     if( m_xDataAccess.is() )
 409         return m_xDataAccess->getRowDescriptions();
 410     return Sequence< OUString >();
 411 }
 412 Sequence< OUString > SAL_CALL ChartDataWrapper::getColumnDescriptions()
 413 {
 414     initDataAccess();
 415     if( m_xDataAccess.is() )
 416         return m_xDataAccess->getColumnDescriptions();
 417     return Sequence< OUString > ();
 418 }
 419
 420 // ____ XComplexDescriptionAccess (read) ____
 421 Sequence< Sequence< OUString > > SAL_CALL ChartDataWrapper::getComplexRowDescriptions()
 422 {
 423     initDataAccess();
 424     if( m_xDataAccess.is() )
 425         return m_xDataAccess->getComplexRowDescriptions();
 426     return Sequence< Sequence< OUString > >();
 427 }
 428 Sequence< Sequence< OUString > > SAL_CALL ChartDataWrapper::getComplexColumnDescriptions()
 429 {
 430     initDataAccess();
 431     if( m_xDataAccess.is() )
 432         return m_xDataAccess->getComplexColumnDescriptions();
 433     return Sequence< Sequence< OUString > >();
 434 }
 435
 436 // ____ XAnyDescriptionAccess (read) ____
 437 Sequence< Sequence< uno::Any > > SAL_CALL ChartDataWrapper::getAnyRowDescriptions()
 438 {
 439     initDataAccess();
 440     if( m_xDataAccess.is() )
 441         return m_xDataAccess->getAnyRowDescriptions();
 442     return Sequence< Sequence< uno::Any > >();
 443 }
 444 Sequence< Sequence< uno::Any > > SAL_CALL ChartDataWrapper::getAnyColumnDescriptions()
 445 {
 446     initDataAccess();
 447     if( m_xDataAccess.is() )
 448         return m_xDataAccess->getAnyColumnDescriptions();
 449     return Sequence< Sequence< uno::Any > >();
 450 }
 451
 452 // ____ XDateCategories (read) ____
 453 Sequence< double > SAL_CALL ChartDataWrapper::getDateCategories()
 454 {
 455     initDataAccess();
 456     Reference< XDateCategories > xDateCategories( m_xDataAccess, uno::UNO_QUERY );
 457     if( xDateCategories.is() )
 458         return xDateCategories->getDateCategories();
 459     return Sequence< double >();
 460 }
 461
 462 // ____ XChartDataArray (write)____
 463 void SAL_CALL ChartDataWrapper::setData( const Sequence< Sequence< double > >& rData )
 464 {
 465     lcl_DataOperator aOperator( rData );
 466     applyData( aOperator );
 467 }
 468 void SAL_CALL ChartDataWrapper::setRowDescriptions( const Sequence< OUString >& rRowDescriptions )
 469 {
 470     lcl_RowDescriptionsOperator aOperator( rRowDescriptions, m_spChart2ModelContact->getChart2Document() );
 471     applyData( aOperator );
 472 }
 473 void SAL_CALL ChartDataWrapper::setColumnDescriptions( const Sequence< OUString >& rColumnDescriptions )
 474 {
 475     lcl_ColumnDescriptionsOperator aOperator( rColumnDescriptions, m_spChart2ModelContact->getChart2Document() );
 476     applyData( aOperator );
 477 }
 478
 479 // ____ XComplexDescriptionAccess (write) ____
 480 void SAL_CALL ChartDataWrapper::setComplexRowDescriptions( const Sequence< Sequence< OUString > >& rRowDescriptions )
 481 {
 482     lcl_ComplexRowDescriptionsOperator aOperator( rRowDescriptions, m_spChart2ModelContact->getChart2Document() );
 483     applyData( aOperator );
 484 }
 485 void SAL_CALL ChartDataWrapper::setComplexColumnDescriptions( const Sequence< Sequence< OUString > >& rColumnDescriptions )
 486 {
 487     lcl_ComplexColumnDescriptionsOperator aOperator( rColumnDescriptions, m_spChart2ModelContact->getChart2Document() );
 488     applyData( aOperator );
 489 }
 490
 491 // ____ XAnyDescriptionAccess (write) ____
 492 void SAL_CALL ChartDataWrapper::setAnyRowDescriptions( const Sequence< Sequence< uno::Any > >& rRowDescriptions )
 493 {
 494     lcl_AnyRowDescriptionsOperator aOperator( rRowDescriptions );
 495     applyData( aOperator );
 496 }
 497 void SAL_CALL ChartDataWrapper::setAnyColumnDescriptions( const Sequence< Sequence< uno::Any > >& rColumnDescriptions )
 498 {
 499     lcl_AnyColumnDescriptionsOperator aOperator( rColumnDescriptions );
 500     applyData( aOperator );
 501 }
 502
 503 // ____ XDateCategories (write) ____
 504 void SAL_CALL ChartDataWrapper::setDateCategories( const Sequence< double >& rDates )
 505 {
 506     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 507     ControllerLockGuardUNO aCtrlLockGuard( xChartDoc );
 508     lcl_DateCategoriesOperator aOperator( rDates );
 509     applyData( aOperator );
 510     DiagramHelper::switchToDateCategories( xChartDoc );
 511 }
 512
 513 // ____ XChartData (base of XChartDataArray) ____
 514 void SAL_CALL ChartDataWrapper::addChartDataChangeEventListener(
 515     const uno::Reference< css::chart::XChartDataChangeEventListener >& aListener )
 516 {
 517     m_aEventListenerContainer.addInterface( aListener );
 518 }
 519
 520 void SAL_CALL ChartDataWrapper::removeChartDataChangeEventListener(
 521     const uno::Reference< css::chart::XChartDataChangeEventListener >& aListener )
 522 {
 523     m_aEventListenerContainer.removeInterface( aListener );
 524 }
 525
 526 double SAL_CALL ChartDataWrapper::getNotANumber()
 527 {
 528     return DBL_MIN;
 529 }
 530
 531 sal_Bool SAL_CALL ChartDataWrapper::isNotANumber( double nNumber )
 532 {
 533     return nNumber == DBL_MIN
 534         || ::rtl::math::isNan( nNumber )
 535         || ::rtl::math::isInf( nNumber );
 536 }
 537
 538 // ____ XComponent ____
 539 void SAL_CALL ChartDataWrapper::dispose()
 540 {
 541     m_aEventListenerContainer.disposeAndClear( lang::EventObject( static_cast< ::cppu::OWeakObject* >( this )));
 542     m_xDataAccess=nullptr;
 543 }
 544
 545 void SAL_CALL ChartDataWrapper::addEventListener(
 546     const uno::Reference< lang::XEventListener > & xListener )
 547 {
 548     m_aEventListenerContainer.addInterface( xListener );
 549 }
 550
 551 void SAL_CALL ChartDataWrapper::removeEventListener(
 552     const uno::Reference< lang::XEventListener >& aListener )
 553 {
 554     m_aEventListenerContainer.removeInterface( aListener );
 555 }
 556
 557 // ____ XEventListener ____
 558 void SAL_CALL ChartDataWrapper::disposing( const lang::EventObject& /* Source */ )
 559 {
 560 }
 561
 562 void ChartDataWrapper::fireChartDataChangeEvent( css::chart::ChartDataChangeEvent& aEvent )
 563 {
 564     if( ! m_aEventListenerContainer.getLength() )
 565         return;
 566
 567     uno::Reference< uno::XInterface > xSrc( static_cast< cppu::OWeakObject* >( this ));
 568     OSL_ASSERT( xSrc.is());
 569     if( xSrc.is() )
 570         aEvent.Source = xSrc;
 571
 572     m_aEventListenerContainer.notifyEach( &css::chart::XChartDataChangeEventListener::chartDataChanged, aEvent );
 573 }
 574
 575 void ChartDataWrapper::switchToInternalDataProvider()
 576 {
 577     //create an internal data provider that is connected to the model
 578     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 579     if( xChartDoc.is() )
 580         xChartDoc->createInternalDataProvider( true /*bCloneExistingData*/ );
 581     initDataAccess();
 582 }
 583
 584 void ChartDataWrapper::initDataAccess()
 585 {
 586     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 587     if( !xChartDoc.is() )
 588         return;
 589     if( xChartDoc->hasInternalDataProvider() )
 590         m_xDataAccess.set( xChartDoc->getDataProvider(), uno::UNO_QUERY_THROW );
 591     else
 592     {
 593         //create a separate "internal data provider" that is not connected to the model
 594         m_xDataAccess.set( ChartModelHelper::createInternalDataProvider(
 595             xChartDoc, false /*bConnectToModel*/ ), uno::UNO_QUERY_THROW );
 596     }
 597 }
 598
 599 void ChartDataWrapper::applyData( lcl_Operator& rDataOperator )
 600 {
 601     //bool bSetValues, bool bSetRowDescriptions, bool bSetColumnDescriptions
 602     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 603     if( !xChartDoc.is() )
 604         return;
 605
 606     // remember some diagram properties to reset later
 607     bool bStacked = false;
 608     bool bPercent = false;
 609     bool bDeep = false;
 610     uno::Reference< css::chart::XChartDocument > xOldDoc( xChartDoc, uno::UNO_QUERY );
 611     OSL_ASSERT( xOldDoc.is());
 612     uno::Reference< beans::XPropertySet > xDiaProp( xOldDoc->getDiagram(), uno::UNO_QUERY );
 613     if( xDiaProp.is())
 614     {
 615         xDiaProp->getPropertyValue("Stacked") >>= bStacked;
 616         xDiaProp->getPropertyValue("Percent") >>= bPercent;
 617         xDiaProp->getPropertyValue("Deep") >>= bDeep;
 618     }
 619
 620     //detect arguments for the new data source
 621     OUString aRangeString;
 622     bool bUseColumns = true;
 623     bool bFirstCellAsLabel = true;
 624     bool bHasCategories = true;
 625     uno::Sequence< sal_Int32 > aSequenceMapping;
 626
 627     DataSourceHelper::detectRangeSegmentation(
 628         xChartDoc,
 629         aRangeString, aSequenceMapping, bUseColumns, bFirstCellAsLabel, bHasCategories );
 630
 631     if( !bHasCategories && rDataOperator.setsCategories( bUseColumns ) )
 632         bHasCategories = true;
 633
 634     aRangeString = "all";
 635     uno::Sequence< beans::PropertyValue > aArguments( DataSourceHelper::createArguments(
 636             aRangeString, aSequenceMapping, bUseColumns, bFirstCellAsLabel, bHasCategories ) );
 637
 638     // -- locked controllers
 639     ControllerLockGuardUNO aCtrlLockGuard( xChartDoc );
 640
 641     // create and attach new data source
 642     switchToInternalDataProvider();
 643     rDataOperator.apply(m_xDataAccess);
 644     uno::Reference< chart2::data::XDataProvider > xDataProvider( xChartDoc->getDataProvider() );
 645     OSL_ASSERT( xDataProvider.is() );
 646     if( !xDataProvider.is() )
 647         return;
 648     uno::Reference< chart2::data::XDataSource > xSource( xDataProvider->createDataSource( aArguments ) );
 649
 650     uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram() );
 651     if( xDia.is() )
 652         xDia->setDiagramData( xSource, aArguments );
 653
 654     //correct stacking mode
 655     if( bStacked || bPercent || bDeep )
 656     {
 657         StackMode eStackMode = StackMode::YStacked;
 658         if( bDeep )
 659             eStackMode = StackMode::ZStacked;
 660         else if( bPercent )
 661             eStackMode = StackMode::YStackedPercent;
 662         DiagramHelper::setStackMode( xDia, eStackMode );
 663     }
 664
 665     // notify listeners
 666     css::chart::ChartDataChangeEvent aEvent(
 667         static_cast< ::cppu::OWeakObject* >( this ),
 668         css::chart::ChartDataChangeType_ALL, 0, 0, 0, 0 );
 669     fireChartDataChangeEvent( aEvent );
 670     // \-- locked controllers
 671 }
 672
 673 OUString SAL_CALL ChartDataWrapper::getImplementationName()
 674 {
 675     return "com.sun.star.comp.chart.ChartData";
 676 }
 677
 678 sal_Bool SAL_CALL ChartDataWrapper::supportsService( const OUString& rServiceName )
 679 {
 680     return cppu::supportsService(this, rServiceName);
 681 }
 682
 683 css::uno::Sequence< OUString > SAL_CALL ChartDataWrapper::getSupportedServiceNames()
 684 {
 685     return {
 686         "com.sun.star.chart.ChartDataArray",
 687         "com.sun.star.chart.ChartData"
 688     };
 689 }
 690
 691 } //  namespace wrapper
 692 } //  namespace chart
 693
 694 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */