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