chart2/source/model/main/ChartModel.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 <ChartModel.hxx>
  21 #include <ChartTypeManager.hxx>
  22 #include <ChartTypeTemplate.hxx>
  23 #include <servicenames.hxx>
  24 #include <DataSource.hxx>
  25 #include <DataSourceHelper.hxx>
  26 #include <ChartModelHelper.hxx>
  27 #include <DisposeHelper.hxx>
  28 #include <ControllerLockGuard.hxx>
  29 #include <InternalDataProvider.hxx>
  30 #include <ObjectIdentifier.hxx>
  31 #include "PageBackground.hxx"
  32 #include <CloneHelper.hxx>
  33 #include <NameContainer.hxx>
  34 #include "UndoManager.hxx"
  35 #include <ChartView.hxx>
  36 #include <PopupRequest.hxx>
  37 #include <ModifyListenerHelper.hxx>
  38 #include <RangeHighlighter.hxx>
  39 #include <Diagram.hxx>
  40 #include <comphelper/dumpxmltostring.hxx>
  41
  42 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  43 #include <com/sun/star/chart2/data/XPivotTableDataProvider.hpp>
  44
  45 #include <comphelper/processfactory.hxx>
  46 #include <comphelper/propertysequence.hxx>
  47 #include <cppuhelper/supportsservice.hxx>
  48
  49 #include <svl/numformat.hxx>
  50 #include <svl/numuno.hxx>
  51 #include <com/sun/star/lang/DisposedException.hpp>
  52 #include <com/sun/star/view/XSelectionSupplier.hpp>
  53 #include <com/sun/star/embed/EmbedMapUnits.hpp>
  54 #include <com/sun/star/embed/Aspects.hpp>
  55 #include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
  56 #include <com/sun/star/datatransfer/XTransferable.hpp>
  57 #include <com/sun/star/drawing/XShapes.hpp>
  58 #include <com/sun/star/document/DocumentProperties.hpp>
  59 #include <com/sun/star/util/CloseVetoException.hpp>
  60 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  61
  62 #include <sal/log.hxx>
  63 #include <utility>
  64 #include <comphelper/diagnose_ex.hxx>
  65 #include <libxml/xmlwriter.h>
  66
  67 using ::com::sun::star::uno::Sequence;
  68 using ::com::sun::star::uno::Reference;
  69 using ::com::sun::star::uno::Any;
  70 using ::osl::MutexGuard;
  71
  72 using namespace ::com::sun::star;
  73 using namespace ::apphelper;
  74
  75 namespace
  76 {
  77 constexpr OUString lcl_aGDIMetaFileMIMEType(
  78     u"application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\""_ustr);
  79 constexpr OUString lcl_aGDIMetaFileMIMETypeHighContrast(
  80     u"application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\""_ustr);
  81
  82 } // anonymous namespace
  83
  84 // ChartModel Constructor and Destructor
  85
  86 namespace chart
  87 {
  88
  89 ChartModel::ChartModel(uno::Reference<uno::XComponentContext > xContext)
  90     : m_aLifeTimeManager( this, this )
  91     , m_bReadOnly( false )
  92     , m_bModified( false )
  93     , m_nInLoad(0)
  94     , m_bUpdateNotificationsPending(false)
  95     , mbTimeBased(false)
  96     , m_aControllers( m_aModelMutex )
  97     , m_nControllerLockCount(0)
  98     , m_xContext(std::move( xContext ))
  99     , m_aVisualAreaSize( ChartModelHelper::getDefaultPageSize() )
 100     , m_xPageBackground( new PageBackground )
 101     , m_xXMLNamespaceMap( new NameContainer() )
 102     , mnStart(0)
 103     , mnEnd(0)
 104 {
 105     osl_atomic_increment(&m_refCount);
 106     {
 107         m_xOldModelAgg.set(
 108             m_xContext->getServiceManager()->createInstanceWithContext(
 109             CHART_CHARTAPIWRAPPER_SERVICE_NAME,
 110             m_xContext ), uno::UNO_QUERY_THROW );
 111         m_xOldModelAgg->setDelegator( *this );
 112     }
 113
 114     {
 115         m_xPageBackground->addModifyListener( this );
 116         m_xChartTypeManager = new ::chart::ChartTypeManager( m_xContext );
 117     }
 118     osl_atomic_decrement(&m_refCount);
 119 }
 120
 121 ChartModel::ChartModel( const ChartModel & rOther )
 122     : impl::ChartModel_Base(rOther)
 123     , m_aLifeTimeManager( this, this )
 124     , m_bReadOnly( rOther.m_bReadOnly )
 125     , m_bModified( rOther.m_bModified )
 126     , m_nInLoad(0)
 127     , m_bUpdateNotificationsPending(false)
 128     , mbTimeBased(rOther.mbTimeBased)
 129     , m_aResource( rOther.m_aResource )
 130     , m_aMediaDescriptor( rOther.m_aMediaDescriptor )
 131     , m_aControllers( m_aModelMutex )
 132     , m_nControllerLockCount(0)
 133     , m_xContext( rOther.m_xContext )
 134     // @note: the old model aggregate must not be shared with other models if it
 135     // is, you get mutex deadlocks
 136     //, m_xOldModelAgg( nullptr ) //rOther.m_xOldModelAgg )
 137     // m_xStorage( nullptr ) //rOther.m_xStorage )
 138     , m_aVisualAreaSize( rOther.m_aVisualAreaSize )
 139     , m_aGraphicObjectVector( rOther.m_aGraphicObjectVector )
 140     , m_xDataProvider( rOther.m_xDataProvider )
 141     , m_xInternalDataProvider( rOther.m_xInternalDataProvider )
 142     , mnStart(rOther.mnStart)
 143     , mnEnd(rOther.mnEnd)
 144 {
 145     osl_atomic_increment(&m_refCount);
 146     {
 147         m_xOldModelAgg.set(
 148             m_xContext->getServiceManager()->createInstanceWithContext(
 149             CHART_CHARTAPIWRAPPER_SERVICE_NAME,
 150             m_xContext ), uno::UNO_QUERY_THROW );
 151         m_xOldModelAgg->setDelegator( *this );
 152
 153         Reference< util::XModifyListener > xListener;
 154         rtl::Reference< Title > xNewTitle;
 155         if ( rOther.m_xTitle )
 156             xNewTitle = new Title(*rOther.m_xTitle);
 157         rtl::Reference< ::chart::Diagram > xNewDiagram;
 158         if (rOther.m_xDiagram.is())
 159             xNewDiagram = new ::chart::Diagram( *rOther.m_xDiagram );
 160         rtl::Reference< ::chart::PageBackground > xNewPageBackground = new PageBackground( *rOther.m_xPageBackground );
 161
 162         {
 163             rtl::Reference< ::chart::ChartTypeManager > xChartTypeManager; // does not implement XCloneable
 164             rtl::Reference< ::chart::NameContainer > xXMLNamespaceMap = new NameContainer( *rOther.m_xXMLNamespaceMap );
 165
 166             {
 167                 MutexGuard aGuard( m_aModelMutex );
 168                 xListener = this;
 169                 m_xTitle = xNewTitle;
 170                 m_xDiagram = xNewDiagram;
 171                 m_xPageBackground = xNewPageBackground;
 172                 m_xChartTypeManager = std::move(xChartTypeManager);
 173                 m_xXMLNamespaceMap = std::move(xXMLNamespaceMap);
 174             }
 175         }
 176
 177         ModifyListenerHelper::addListener( xNewTitle, xListener );
 178         if( xNewDiagram && xListener)
 179             xNewDiagram->addModifyListener( xListener );
 180         if( xNewPageBackground && xListener)
 181             xNewPageBackground->addModifyListener( xListener );
 182         xListener.clear();
 183     }
 184     osl_atomic_decrement(&m_refCount);
 185 }
 186
 187 ChartModel::~ChartModel()
 188 {
 189     if( m_xOldModelAgg.is())
 190         m_xOldModelAgg->setDelegator( nullptr );
 191 }
 192
 193 void SAL_CALL ChartModel::initialize( const Sequence< Any >& /*rArguments*/ )
 194 {
 195     //#i113722# avoid duplicate creation
 196
 197     //maybe additional todo?:
 198     //support argument "EmbeddedObject"?
 199     //support argument "EmbeddedScriptSupport"?
 200     //support argument "DocumentRecoverySupport"?
 201 }
 202
 203 ChartView* ChartModel::getChartView() const
 204 {
 205     return mxChartView.get();
 206 }
 207
 208 // private methods
 209
 210 OUString ChartModel::impl_g_getLocation()
 211 {
 212
 213     LifeTimeGuard aGuard(m_aLifeTimeManager);
 214     if(!aGuard.startApiCall())
 215         return OUString(); //behave passive if already disposed or closed or throw exception @todo?
 216     //mutex is acquired
 217     return m_aResource;
 218 }
 219
 220 bool ChartModel::impl_isControllerConnected( const uno::Reference< frame::XController >& xController )
 221 {
 222     try
 223     {
 224         std::vector< uno::Reference<uno::XInterface> > aSeq = m_aControllers.getElements();
 225         for( const auto & r : aSeq )
 226         {
 227             if( r == xController )
 228                 return true;
 229         }
 230     }
 231     catch (const uno::Exception&)
 232     {
 233     }
 234     return false;
 235 }
 236
 237 uno::Reference< frame::XController > ChartModel::impl_getCurrentController()
 238 {
 239         //@todo? hold only weak references to controllers
 240
 241     // get the last active controller of this model
 242     if( m_xCurrentController.is() )
 243         return m_xCurrentController;
 244
 245     // get the first controller of this model
 246     if( m_aControllers.getLength() )
 247     {
 248         uno::Reference<uno::XInterface> xI = m_aControllers.getInterface(0);
 249         return uno::Reference<frame::XController>( xI, uno::UNO_QUERY );
 250     }
 251
 252     //return nothing if no controllers are connected at all
 253     return uno::Reference< frame::XController > ();
 254 }
 255
 256 void ChartModel::impl_notifyCloseListeners()
 257 {
 258     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 259     if( m_aLifeTimeManager.m_aCloseListeners.getLength(aGuard) )
 260     {
 261         lang::EventObject aEvent( static_cast< lang::XComponent*>(this) );
 262         m_aLifeTimeManager.m_aCloseListeners.notifyEach(aGuard, &util::XCloseListener::notifyClosing, aEvent);
 263     }
 264 }
 265
 266 void ChartModel::impl_adjustAdditionalShapesPositionAndSize( const awt::Size& aVisualAreaSize )
 267 {
 268     uno::Reference< beans::XPropertySet > xProperties( static_cast< ::cppu::OWeakObject* >( this ), uno::UNO_QUERY );
 269     if ( !xProperties.is() )
 270         return;
 271
 272     uno::Reference< drawing::XShapes > xShapes;
 273     xProperties->getPropertyValue( u"AdditionalShapes"_ustr ) >>= xShapes;
 274     if ( !xShapes.is() )
 275         return;
 276
 277     sal_Int32 nCount = xShapes->getCount();
 278     for ( sal_Int32 i = 0; i < nCount; ++i )
 279     {
 280         Reference< drawing::XShape > xShape;
 281         if ( xShapes->getByIndex( i ) >>= xShape )
 282         {
 283             if ( xShape.is() )
 284             {
 285                 awt::Point aPos( xShape->getPosition() );
 286                 awt::Size aSize( xShape->getSize() );
 287
 288                 double fWidth = static_cast< double >( aVisualAreaSize.Width ) / m_aVisualAreaSize.Width;
 289                 double fHeight = static_cast< double >( aVisualAreaSize.Height ) / m_aVisualAreaSize.Height;
 290
 291                 aPos.X = static_cast< tools::Long >( aPos.X * fWidth );
 292                 aPos.Y = static_cast< tools::Long >( aPos.Y * fHeight );
 293                 aSize.Width = static_cast< tools::Long >( aSize.Width * fWidth );
 294                 aSize.Height = static_cast< tools::Long >( aSize.Height * fHeight );
 295
 296                 xShape->setPosition( aPos );
 297                 xShape->setSize( aSize );
 298             }
 299         }
 300     }
 301 }
 302
 303 // lang::XServiceInfo
 304
 305 OUString SAL_CALL ChartModel::getImplementationName()
 306 {
 307     return CHART_MODEL_SERVICE_IMPLEMENTATION_NAME;
 308 }
 309
 310 sal_Bool SAL_CALL ChartModel::supportsService( const OUString& rServiceName )
 311 {
 312     return cppu::supportsService(this, rServiceName);
 313 }
 314
 315 css::uno::Sequence< OUString > SAL_CALL ChartModel::getSupportedServiceNames()
 316 {
 317     return {
 318         CHART_MODEL_SERVICE_NAME,
 319         u"com.sun.star.document.OfficeDocument"_ustr,
 320         u"com.sun.star.chart.ChartDocument"_ustr
 321     };
 322 }
 323
 324 // frame::XModel (required interface)
 325
 326 sal_Bool SAL_CALL ChartModel::attachResource( const OUString& rURL
 327         , const uno::Sequence< beans::PropertyValue >& rMediaDescriptor )
 328 {
 329     /*
 330     The method attachResource() is used by the frame loader implementations
 331     to inform the model about its URL and MediaDescriptor.
 332     */
 333
 334     LifeTimeGuard aGuard(m_aLifeTimeManager);
 335     if(!aGuard.startApiCall())
 336         return false; //behave passive if already disposed or closed or throw exception @todo?
 337     //mutex is acquired
 338
 339     if(!m_aResource.isEmpty())//we have a resource already //@todo? or is setting a new resource allowed?
 340         return false;
 341     m_aResource = rURL;
 342     m_aMediaDescriptor = rMediaDescriptor;
 343
 344     //@todo ? check rURL ??
 345     //@todo ? evaluate m_aMediaDescriptor;
 346     //@todo ? ... ??? --> nothing, this method is only for setting information
 347
 348     return true;
 349 }
 350
 351 OUString SAL_CALL ChartModel::getURL()
 352 {
 353     return impl_g_getLocation();
 354 }
 355
 356 uno::Sequence< beans::PropertyValue > SAL_CALL ChartModel::getArgs()
 357 {
 358     /*
 359     The method getArgs() returns a sequence of property values
 360     that report the resource description according to com.sun.star.document.MediaDescriptor,
 361     specified on loading or saving with storeAsURL.
 362     */
 363
 364     LifeTimeGuard aGuard(m_aLifeTimeManager);
 365     if(!aGuard.startApiCall())
 366         return uno::Sequence< beans::PropertyValue >(); //behave passive if already disposed or closed or throw exception @todo?
 367     //mutex is acquired
 368
 369     return m_aMediaDescriptor;
 370 }
 371
 372 void SAL_CALL ChartModel::connectController( const uno::Reference< frame::XController >& xController )
 373 {
 374     //@todo? this method is declared as oneway -> ...?
 375
 376     LifeTimeGuard aGuard(m_aLifeTimeManager);
 377     if(!aGuard.startApiCall())
 378         return ; //behave passive if already disposed or closed
 379     //mutex is acquired
 380
 381     //--add controller
 382     m_aControllers.addInterface(xController);
 383 }
 384
 385 void SAL_CALL ChartModel::disconnectController( const uno::Reference< frame::XController >& xController )
 386 {
 387     //@todo? this method is declared as oneway -> ...?
 388
 389     LifeTimeGuard aGuard(m_aLifeTimeManager);
 390     if(!aGuard.startApiCall())
 391         return; //behave passive if already disposed or closed
 392
 393     //--remove controller
 394     m_aControllers.removeInterface(xController);
 395
 396     //case: current controller is disconnected:
 397     if( m_xCurrentController == xController )
 398         m_xCurrentController.clear();
 399
 400     if (m_xRangeHighlighter)
 401     {
 402         m_xRangeHighlighter->dispose();
 403         m_xRangeHighlighter.clear();
 404     }
 405     DisposeHelper::DisposeAndClear(m_xPopupRequest);
 406 }
 407
 408 void SAL_CALL ChartModel::lockControllers()
 409 {
 410     /*
 411     suspends some notifications to the controllers which are used for display updates.
 412
 413     The calls to lockControllers() and unlockControllers() may be nested
 414     and even overlapping, but they must be in pairs. While there is at least one lock
 415     remaining, some notifications for display updates are not broadcasted.
 416     */
 417
 418     //@todo? this method is declared as oneway -> ...?
 419
 420     LifeTimeGuard aGuard(m_aLifeTimeManager);
 421     if(!aGuard.startApiCall())
 422         return; //behave passive if already disposed or closed or throw exception @todo?
 423     ++m_nControllerLockCount;
 424 }
 425
 426 void SAL_CALL ChartModel::unlockControllers()
 427 {
 428     /*
 429     resumes the notifications which were suspended by lockControllers() .
 430
 431     The calls to lockControllers() and unlockControllers() may be nested
 432     and even overlapping, but they must be in pairs. While there is at least one lock
 433     remaining, some notifications for display updates are not broadcasted.
 434     */
 435
 436     //@todo? this method is declared as oneway -> ...?
 437
 438     LifeTimeGuard aGuard(m_aLifeTimeManager);
 439     if(!aGuard.startApiCall())
 440         return; //behave passive if already disposed or closed or throw exception @todo?
 441     if( m_nControllerLockCount == 0 )
 442     {
 443         SAL_WARN("chart2",  "ChartModel: unlockControllers called with m_nControllerLockCount == 0" );
 444         return;
 445     }
 446     --m_nControllerLockCount;
 447     if( m_nControllerLockCount == 0 && m_bUpdateNotificationsPending  )
 448     {
 449         aGuard.clear();
 450         impl_notifyModifiedListeners();
 451     }
 452 }
 453
 454 sal_Bool SAL_CALL ChartModel::hasControllersLocked()
 455 {
 456     LifeTimeGuard aGuard(m_aLifeTimeManager);
 457     if(!aGuard.startApiCall())
 458         return false; //behave passive if already disposed or closed or throw exception @todo?
 459     return ( m_nControllerLockCount != 0 ) ;
 460 }
 461
 462 uno::Reference< frame::XController > SAL_CALL ChartModel::getCurrentController()
 463 {
 464     LifeTimeGuard aGuard(m_aLifeTimeManager);
 465     if(!aGuard.startApiCall())
 466         throw lang::DisposedException(
 467                 u"getCurrentController was called on an already disposed or closed model"_ustr,
 468                 static_cast< ::cppu::OWeakObject* >(this) );
 469
 470     return impl_getCurrentController();
 471 }
 472
 473 void SAL_CALL ChartModel::setCurrentController( const uno::Reference< frame::XController >& xController )
 474 {
 475     LifeTimeGuard aGuard(m_aLifeTimeManager);
 476     if(!aGuard.startApiCall())
 477         throw lang::DisposedException(
 478                 u"setCurrentController was called on an already disposed or closed model"_ustr,
 479                 static_cast< ::cppu::OWeakObject* >(this) );
 480
 481     //OSL_ENSURE( impl_isControllerConnected(xController), "setCurrentController is called with a Controller which is not connected" );
 482     if(!impl_isControllerConnected(xController))
 483         throw container::NoSuchElementException(
 484                 u"setCurrentController is called with a Controller which is not connected"_ustr,
 485                 static_cast< ::cppu::OWeakObject* >(this) );
 486
 487     m_xCurrentController = xController;
 488
 489     if (m_xRangeHighlighter)
 490     {
 491         m_xRangeHighlighter->dispose();
 492         m_xRangeHighlighter.clear();
 493     }
 494     DisposeHelper::DisposeAndClear(m_xPopupRequest);
 495 }
 496
 497 uno::Reference< uno::XInterface > SAL_CALL ChartModel::getCurrentSelection()
 498 {
 499     LifeTimeGuard aGuard(m_aLifeTimeManager);
 500     if(!aGuard.startApiCall())
 501         throw lang::DisposedException(
 502                 u"getCurrentSelection was called on an already disposed or closed model"_ustr,
 503                 static_cast< ::cppu::OWeakObject* >(this) );
 504
 505     uno::Reference< uno::XInterface > xReturn;
 506     uno::Reference< frame::XController > xController = impl_getCurrentController();
 507
 508     aGuard.clear();
 509     if( xController.is() )
 510     {
 511         uno::Reference< view::XSelectionSupplier >  xSelectionSupl( xController, uno::UNO_QUERY );
 512         if ( xSelectionSupl.is() )
 513         {
 514             uno::Any aSel = xSelectionSupl->getSelection();
 515             OUString aObjectCID;
 516             if( aSel >>= aObjectCID )
 517                 xReturn.set( ObjectIdentifier::getObjectPropertySet( aObjectCID, this));
 518         }
 519     }
 520     return xReturn;
 521 }
 522
 523 // lang::XComponent (base of XModel)
 524 void SAL_CALL ChartModel::dispose()
 525 {
 526     Reference< XInterface > xKeepAlive( *this );
 527
 528     //This object should release all resources and references in the
 529     //easiest possible manner
 530     //This object must notify all registered listeners using the method
 531     //<member>XEventListener::disposing</member>
 532
 533     //hold no mutex
 534     if( !m_aLifeTimeManager.dispose() )
 535         return;
 536
 537     //--release all resources and references
 538     //// @todo
 539
 540     if ( m_xDiagram.is() )
 541         m_xDiagram->removeModifyListener( this );
 542
 543     if ( m_xDataProvider.is() )
 544     {
 545         Reference<util::XModifyBroadcaster> xModifyBroadcaster( m_xDataProvider, uno::UNO_QUERY );
 546         if ( xModifyBroadcaster.is() )
 547             xModifyBroadcaster->removeModifyListener( this );
 548     }
 549
 550     m_xDataProvider.clear();
 551     m_xInternalDataProvider.clear();
 552     m_xNumberFormatsSupplier.clear();
 553     m_xOwnNumberFormatsSupplier.clear();
 554     m_xChartTypeManager.clear();
 555     m_xDiagram.clear();
 556     m_xTitle.clear();
 557     m_xPageBackground.clear();
 558     m_xXMLNamespaceMap.clear();
 559
 560     m_xStorage.clear();
 561         // just clear, don't dispose - we're not the owner
 562
 563     if ( m_pUndoManager.is() )
 564         m_pUndoManager->disposing();
 565     m_pUndoManager.clear();
 566         // that's important, since the UndoManager implementation delegates its ref counting to ourself.
 567
 568     if( m_xOldModelAgg.is())  // #i120828#, to release cyclic reference to ChartModel object
 569         m_xOldModelAgg->setDelegator( nullptr );
 570
 571     m_aControllers.disposeAndClear( lang::EventObject( static_cast< cppu::OWeakObject * >( this )));
 572     m_xCurrentController.clear();
 573
 574     if (m_xRangeHighlighter)
 575     {
 576         m_xRangeHighlighter->dispose();
 577         m_xRangeHighlighter.clear();
 578     }
 579     DisposeHelper::DisposeAndClear(m_xPopupRequest);
 580
 581     if( m_xOldModelAgg.is())
 582         m_xOldModelAgg->setDelegator( nullptr );
 583 }
 584
 585 void SAL_CALL ChartModel::addEventListener( const uno::Reference< lang::XEventListener > & xListener )
 586 {
 587     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 588         return; //behave passive if already disposed or closed
 589
 590     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 591     m_aLifeTimeManager.m_aEventListeners.addInterface( aGuard, xListener );
 592 }
 593
 594 void SAL_CALL ChartModel::removeEventListener( const uno::Reference< lang::XEventListener > & xListener )
 595 {
 596     if( m_aLifeTimeManager.impl_isDisposedOrClosed(false) )
 597         return; //behave passive if already disposed or closed
 598
 599     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 600     m_aLifeTimeManager.m_aEventListeners.removeInterface( aGuard, xListener );
 601 }
 602
 603 // util::XCloseBroadcaster (base of XCloseable)
 604 void SAL_CALL ChartModel::addCloseListener( const uno::Reference<   util::XCloseListener > & xListener )
 605 {
 606     m_aLifeTimeManager.g_addCloseListener( xListener );
 607 }
 608
 609 void SAL_CALL ChartModel::removeCloseListener( const uno::Reference< util::XCloseListener > & xListener )
 610 {
 611     if( m_aLifeTimeManager.impl_isDisposedOrClosed(false) )
 612         return; //behave passive if already disposed or closed
 613
 614     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 615     m_aLifeTimeManager.m_aCloseListeners.removeInterface( aGuard, xListener );
 616 }
 617
 618 // util::XCloseable
 619 void SAL_CALL ChartModel::close( sal_Bool bDeliverOwnership )
 620 {
 621     //hold no mutex
 622
 623     if( !m_aLifeTimeManager.g_close_startTryClose( bDeliverOwnership ) )
 624         return;
 625     //no mutex is acquired
 626
 627     // At the end of this method may we must dispose ourself ...
 628     // and may nobody from outside hold a reference to us ...
 629     // then it's a good idea to do that by ourself.
 630     uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >(this) );
 631
 632     //the listeners have had no veto
 633     //check whether we self can close
 634     {
 635         util::CloseVetoException aVetoException(
 636                         u"the model itself could not be closed"_ustr,
 637                         static_cast< ::cppu::OWeakObject* >(this) );
 638
 639         m_aLifeTimeManager.g_close_isNeedToCancelLongLastingCalls( bDeliverOwnership, aVetoException );
 640     }
 641     m_aLifeTimeManager.g_close_endTryClose_doClose();
 642
 643     // BM @todo: is it ok to call the listeners here?
 644     impl_notifyCloseListeners();
 645 }
 646
 647 // lang::XTypeProvider
 648 uno::Sequence< uno::Type > SAL_CALL ChartModel::getTypes()
 649 {
 650     uno::Reference< lang::XTypeProvider > xAggTypeProvider;
 651     if( (m_xOldModelAgg->queryAggregation( cppu::UnoType<decltype(xAggTypeProvider)>::get()) >>= xAggTypeProvider)
 652         && xAggTypeProvider.is())
 653     {
 654         return comphelper::concatSequences(
 655             impl::ChartModel_Base::getTypes(),
 656             xAggTypeProvider->getTypes());
 657     }
 658
 659     return impl::ChartModel_Base::getTypes();
 660 }
 661
 662 // document::XDocumentPropertiesSupplier
 663 uno::Reference< document::XDocumentProperties > SAL_CALL
 664         ChartModel::getDocumentProperties()
 665 {
 666     ::osl::MutexGuard aGuard( m_aModelMutex );
 667     if ( !m_xDocumentProperties.is() )
 668     {
 669         m_xDocumentProperties.set( document::DocumentProperties::create( ::comphelper::getProcessComponentContext() ) );
 670     }
 671     return m_xDocumentProperties;
 672 }
 673
 674 // document::XDocumentPropertiesSupplier
 675 Reference< document::XUndoManager > SAL_CALL ChartModel::getUndoManager(  )
 676 {
 677     ::osl::MutexGuard aGuard( m_aModelMutex );
 678     if ( !m_pUndoManager.is() )
 679         m_pUndoManager.set( new UndoManager( *this, m_aModelMutex ) );
 680     return m_pUndoManager;
 681 }
 682
 683 // chart2::XChartDocument
 684
 685 uno::Reference< chart2::XDiagram > SAL_CALL ChartModel::getFirstDiagram()
 686 {
 687     MutexGuard aGuard( m_aModelMutex );
 688     return m_xDiagram;
 689 }
 690
 691 void SAL_CALL ChartModel::setFirstDiagram( const uno::Reference< chart2::XDiagram >& xDiagram )
 692 {
 693     rtl::Reference< ::chart::Diagram > xOldDiagram;
 694     Reference< util::XModifyListener > xListener;
 695     {
 696         MutexGuard aGuard( m_aModelMutex );
 697         if( xDiagram.get() == m_xDiagram.get() )
 698             return;
 699         xOldDiagram = m_xDiagram;
 700         assert(!xDiagram || dynamic_cast<::chart::Diagram*>(xDiagram.get()));
 701         m_xDiagram = dynamic_cast<::chart::Diagram*>(xDiagram.get());
 702         xListener = this;
 703     }
 704     //don't keep the mutex locked while calling out
 705     if( xOldDiagram && xListener )
 706         xOldDiagram->removeModifyListener( xListener );
 707     ModifyListenerHelper::addListener( xDiagram, xListener );
 708     setModified( true );
 709 }
 710
 711 Reference< chart2::data::XDataSource > ChartModel::impl_createDefaultData()
 712 {
 713     Reference< chart2::data::XDataSource > xDataSource;
 714     if( hasInternalDataProvider() )
 715     {
 716         //init internal dataprovider
 717         {
 718             beans::NamedValue aParam( u"CreateDefaultData"_ustr ,uno::Any(true) );
 719             uno::Sequence< uno::Any > aArgs{ uno::Any(aParam) };
 720             m_xInternalDataProvider->initialize(aArgs);
 721         }
 722         //create data
 723         uno::Sequence<beans::PropertyValue> aArgs( comphelper::InitPropertySequence({
 724             { "CellRangeRepresentation", uno::Any( u"all"_ustr ) },
 725             { "HasCategories", uno::Any( true ) },
 726             { "FirstCellAsLabel", uno::Any( true ) },
 727             { "DataRowSource", uno::Any( css::chart::ChartDataRowSource_COLUMNS ) }
 728             }));
 729         xDataSource = m_xInternalDataProvider->createDataSource( aArgs );
 730     }
 731     return xDataSource;
 732 }
 733
 734 void SAL_CALL ChartModel::createInternalDataProvider( sal_Bool bCloneExistingData )
 735 {
 736     // don't lock the mutex, because this call calls out to code that tries to
 737     // lock the solar mutex. On the other hand, a paint locks the solar mutex
 738     // and calls to the model lock the model's mutex => deadlock
 739     // @todo: lock a separate mutex in the InternalData class
 740     if( !hasInternalDataProvider() )
 741     {
 742         if( bCloneExistingData )
 743             m_xInternalDataProvider = ChartModelHelper::createInternalDataProvider( this, true );
 744         else
 745         {
 746             m_xInternalDataProvider = ChartModelHelper::createInternalDataProvider( nullptr, true );
 747             m_xInternalDataProvider->setChartModel(this);
 748         }
 749         m_xDataProvider.set( m_xInternalDataProvider );
 750     }
 751     setModified( true );
 752 }
 753
 754 void ChartModel::removeDataProviders()
 755 {
 756     if (m_xInternalDataProvider.is())
 757         m_xInternalDataProvider.clear();
 758     if (m_xDataProvider.is())
 759         m_xDataProvider.clear();
 760 }
 761
 762 void ChartModel::dumpAsXml(xmlTextWriterPtr pWriter) const
 763 {
 764     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ChartModel"));
 765     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
 766
 767     if (mxChartView.is())
 768     {
 769         mxChartView->dumpAsXml(pWriter);
 770     }
 771
 772     (void)xmlTextWriterEndElement(pWriter);
 773 }
 774
 775 sal_Bool SAL_CALL ChartModel::hasInternalDataProvider()
 776 {
 777     return m_xDataProvider.is() && m_xInternalDataProvider.is();
 778 }
 779
 780 uno::Reference< chart2::data::XDataProvider > SAL_CALL ChartModel::getDataProvider()
 781 {
 782     MutexGuard aGuard( m_aModelMutex );
 783     return m_xDataProvider;
 784 }
 785
 786 // ____ XDataReceiver ____
 787
 788 void SAL_CALL ChartModel::attachDataProvider( const uno::Reference< chart2::data::XDataProvider >& xDataProvider )
 789 {
 790     {
 791         MutexGuard aGuard( m_aModelMutex );
 792         uno::Reference< beans::XPropertySet > xProp( xDataProvider, uno::UNO_QUERY );
 793         if( xProp.is() )
 794         {
 795             try
 796             {
 797                 bool bIncludeHiddenCells = ChartModelHelper::isIncludeHiddenCells( this );
 798                 xProp->setPropertyValue(u"IncludeHiddenCells"_ustr, uno::Any(bIncludeHiddenCells));
 799             }
 800             catch (const beans::UnknownPropertyException&)
 801             {
 802             }
 803         }
 804
 805         uno::Reference<util::XModifyBroadcaster> xModifyBroadcaster(xDataProvider, uno::UNO_QUERY);
 806         if (xModifyBroadcaster.is())
 807         {
 808             xModifyBroadcaster->addModifyListener(this);
 809         }
 810
 811         m_xDataProvider.set( xDataProvider );
 812         m_xInternalDataProvider.clear();
 813
 814         //the numberformatter is kept independent of the data provider!
 815     }
 816     setModified( true );
 817 }
 818
 819 void SAL_CALL ChartModel::attachNumberFormatsSupplier( const uno::Reference< util::XNumberFormatsSupplier >& xNewSupplier )
 820 {
 821     {
 822         MutexGuard aGuard( m_aModelMutex );
 823         if( xNewSupplier == m_xNumberFormatsSupplier )
 824             return;
 825         if( xNewSupplier == uno::Reference<XNumberFormatsSupplier>(m_xOwnNumberFormatsSupplier) )
 826             return;
 827         if( m_xOwnNumberFormatsSupplier.is() && xNewSupplier.is() )
 828         {
 829             //@todo
 830             //merge missing numberformats from own to new formatter
 831         }
 832         else if( !xNewSupplier.is() )
 833         {
 834             if( m_xNumberFormatsSupplier.is() )
 835             {
 836                 //@todo
 837                 //merge missing numberformats from old numberformatter to own numberformatter
 838                 //create own numberformatter if necessary
 839             }
 840         }
 841
 842         m_xNumberFormatsSupplier.set( xNewSupplier );
 843         m_xOwnNumberFormatsSupplier.clear();
 844     }
 845     setModified( true );
 846 }
 847
 848 void SAL_CALL ChartModel::setArguments( const Sequence< beans::PropertyValue >& aArguments )
 849 {
 850     {
 851         MutexGuard aGuard( m_aModelMutex );
 852         if( !m_xDataProvider.is() )
 853             return;
 854         lockControllers();
 855
 856         try
 857         {
 858             Reference< chart2::data::XDataSource > xDataSource( m_xDataProvider->createDataSource( aArguments ) );
 859             if( xDataSource.is() )
 860             {
 861                 rtl::Reference< Diagram > xDia = getFirstChartDiagram();
 862                 if( !xDia.is() )
 863                 {
 864                     rtl::Reference< ::chart::ChartTypeTemplate > xTemplate( impl_createDefaultChartTypeTemplate() );
 865                     if( xTemplate.is())
 866                         setFirstDiagram( xTemplate->createDiagramByDataSource( xDataSource, aArguments ) );
 867                 }
 868                 else
 869                     xDia->setDiagramData( xDataSource, aArguments );
 870             }
 871         }
 872         catch (const lang::IllegalArgumentException&)
 873         {
 874             throw;
 875         }
 876         catch (const uno::Exception&)
 877         {
 878             DBG_UNHANDLED_EXCEPTION("chart2");
 879         }
 880         unlockControllers();
 881     }
 882     setModified( true );
 883 }
 884
 885 Sequence< OUString > SAL_CALL ChartModel::getUsedRangeRepresentations()
 886 {
 887     return DataSourceHelper::getUsedDataRanges( this );
 888 }
 889
 890 Reference< chart2::data::XDataSource > SAL_CALL ChartModel::getUsedData()
 891 {
 892     return DataSourceHelper::getUsedData( *this );
 893 }
 894
 895 Reference< chart2::data::XRangeHighlighter > SAL_CALL ChartModel::getRangeHighlighter()
 896 {
 897     if( ! m_xRangeHighlighter.is())
 898         m_xRangeHighlighter = new RangeHighlighter( this );
 899     return m_xRangeHighlighter;
 900 }
 901
 902 Reference<awt::XRequestCallback> SAL_CALL ChartModel::getPopupRequest()
 903 {
 904     if (!m_xPopupRequest.is())
 905         m_xPopupRequest.set(new PopupRequest);
 906     return m_xPopupRequest;
 907 }
 908
 909 rtl::Reference< ::chart::ChartTypeTemplate > ChartModel::impl_createDefaultChartTypeTemplate()
 910 {
 911     rtl::Reference< ::chart::ChartTypeTemplate > xTemplate;
 912     if( m_xChartTypeManager.is() )
 913         xTemplate = m_xChartTypeManager->createTemplate( u"com.sun.star.chart2.template.Column"_ustr );
 914     return xTemplate;
 915 }
 916
 917 void SAL_CALL ChartModel::setChartTypeManager( const uno::Reference< chart2::XChartTypeManager >& xNewManager )
 918 {
 919     {
 920         MutexGuard aGuard( m_aModelMutex );
 921         m_xChartTypeManager = dynamic_cast<::chart::ChartTypeManager*>(xNewManager.get());
 922         assert(!xNewManager || m_xChartTypeManager);
 923     }
 924     setModified( true );
 925 }
 926
 927 uno::Reference< chart2::XChartTypeManager > SAL_CALL ChartModel::getChartTypeManager()
 928 {
 929     MutexGuard aGuard( m_aModelMutex );
 930     return m_xChartTypeManager;
 931 }
 932
 933 uno::Reference< beans::XPropertySet > SAL_CALL ChartModel::getPageBackground()
 934 {
 935     MutexGuard aGuard( m_aModelMutex );
 936     return m_xPageBackground;
 937 }
 938
 939 void SAL_CALL ChartModel::createDefaultChart()
 940 {
 941     insertDefaultChart();
 942 }
 943
 944 // ____ XTitled ____
 945 uno::Reference< chart2::XTitle > SAL_CALL ChartModel::getTitleObject()
 946 {
 947     MutexGuard aGuard( m_aModelMutex );
 948     return m_xTitle;
 949 }
 950
 951 rtl::Reference< Title > ChartModel::getTitleObject2() const
 952 {
 953     MutexGuard aGuard( m_aModelMutex );
 954     return m_xTitle;
 955 }
 956
 957 void SAL_CALL ChartModel::setTitleObject( const uno::Reference< chart2::XTitle >& xNewTitle )
 958 {
 959     rtl::Reference<Title> xTitle = dynamic_cast<Title*>(xNewTitle.get());
 960     assert(!xNewTitle || xTitle);
 961     setTitleObject(xTitle);
 962 }
 963
 964 void ChartModel::setTitleObject( const rtl::Reference< Title >& xTitle )
 965 {
 966     {
 967         MutexGuard aGuard( m_aModelMutex );
 968         if( m_xTitle.is() )
 969             ModifyListenerHelper::removeListener( m_xTitle, this );
 970         m_xTitle = xTitle;
 971         ModifyListenerHelper::addListener( m_xTitle, this );
 972     }
 973     setModified( true );
 974 }
 975
 976 // ____ XInterface (for old API wrapper) ____
 977 uno::Any SAL_CALL ChartModel::queryInterface( const uno::Type& aType )
 978 {
 979     uno::Any aResult( impl::ChartModel_Base::queryInterface( aType ));
 980
 981     if( ! aResult.hasValue())
 982     {
 983         // try old API wrapper
 984         try
 985         {
 986             if( m_xOldModelAgg.is())
 987                 aResult = m_xOldModelAgg->queryAggregation( aType );
 988         }
 989         catch (const uno::Exception&)
 990         {
 991             DBG_UNHANDLED_EXCEPTION("chart2");
 992         }
 993     }
 994
 995     return aResult;
 996 }
 997
 998 // ____ XCloneable ____
 999 Reference< util::XCloneable > SAL_CALL ChartModel::createClone()
1000 {
1001     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
1002     return Reference< util::XCloneable >( new ChartModel( *this ));
1003 }
1004
1005 // ____ XVisualObject ____
1006 void SAL_CALL ChartModel::setVisualAreaSize( ::sal_Int64 nAspect, const awt::Size& aSize )
1007 {
1008     if( nAspect == embed::Aspects::MSOLE_CONTENT )
1009     {
1010         ControllerLockGuard aLockGuard( *this );
1011         bool bChanged =
1012             (m_aVisualAreaSize.Width != aSize.Width ||
1013              m_aVisualAreaSize.Height != aSize.Height);
1014
1015         // #i12587# support for shapes in chart
1016         if ( bChanged )
1017         {
1018             impl_adjustAdditionalShapesPositionAndSize( aSize );
1019         }
1020
1021         m_aVisualAreaSize = aSize;
1022         if( bChanged )
1023             setModified( true );
1024     }
1025     else
1026     {
1027         OSL_FAIL( "setVisualAreaSize: Aspect not implemented yet.");
1028     }
1029 }
1030
1031 awt::Size SAL_CALL ChartModel::getVisualAreaSize( ::sal_Int64 nAspect )
1032 {
1033     OSL_ENSURE( nAspect == embed::Aspects::MSOLE_CONTENT,
1034                 "No aspects other than content are supported" );
1035     // other possible aspects are MSOLE_THUMBNAIL, MSOLE_ICON and MSOLE_DOCPRINT
1036
1037     return m_aVisualAreaSize;
1038 }
1039
1040 embed::VisualRepresentation SAL_CALL ChartModel::getPreferredVisualRepresentation( ::sal_Int64 nAspect )
1041 {
1042     OSL_ENSURE( nAspect == embed::Aspects::MSOLE_CONTENT,
1043                 "No aspects other than content are supported" );
1044
1045     embed::VisualRepresentation aResult;
1046
1047     try
1048     {
1049         Sequence< sal_Int8 > aMetafile;
1050
1051         //get view from old api wrapper
1052         Reference< datatransfer::XTransferable > xTransferable(
1053             createInstance( CHART_VIEW_SERVICE_NAME ), uno::UNO_QUERY );
1054         if( xTransferable.is() )
1055         {
1056             datatransfer::DataFlavor aDataFlavor( lcl_aGDIMetaFileMIMEType,
1057                     u"GDIMetaFile"_ustr,
1058                     cppu::UnoType<uno::Sequence< sal_Int8 >>::get() );
1059
1060             uno::Any aData( xTransferable->getTransferData( aDataFlavor ) );
1061             aData >>= aMetafile;
1062         }
1063
1064         aResult.Flavor.MimeType = lcl_aGDIMetaFileMIMEType;
1065         aResult.Flavor.DataType = cppu::UnoType<decltype(aMetafile)>::get();
1066
1067         aResult.Data <<= aMetafile;
1068     }
1069     catch (const uno::Exception&)
1070     {
1071         DBG_UNHANDLED_EXCEPTION("chart2");
1072     }
1073
1074     return aResult;
1075 }
1076
1077 ::sal_Int32 SAL_CALL ChartModel::getMapUnit( ::sal_Int64 nAspect )
1078 {
1079     OSL_ENSURE( nAspect == embed::Aspects::MSOLE_CONTENT,
1080                 "No aspects other than content are supported" );
1081     return embed::EmbedMapUnits::ONE_100TH_MM;
1082 }
1083
1084 // ____ datatransfer::XTransferable ____
1085 uno::Any SAL_CALL ChartModel::getTransferData( const datatransfer::DataFlavor& aFlavor )
1086 {
1087     uno::Any aResult;
1088     if( !isDataFlavorSupported( aFlavor ) )
1089         throw datatransfer::UnsupportedFlavorException(
1090             aFlavor.MimeType, static_cast< ::cppu::OWeakObject* >( this ));
1091
1092     try
1093     {
1094         //get view from old api wrapper
1095         Reference< datatransfer::XTransferable > xTransferable(
1096             createInstance( CHART_VIEW_SERVICE_NAME ), uno::UNO_QUERY );
1097         if( xTransferable.is() &&
1098             xTransferable->isDataFlavorSupported( aFlavor ))
1099         {
1100             aResult = xTransferable->getTransferData( aFlavor );
1101         }
1102     }
1103     catch (const uno::Exception&)
1104     {
1105         DBG_UNHANDLED_EXCEPTION("chart2");
1106     }
1107
1108     return aResult;
1109 }
1110
1111 Sequence< datatransfer::DataFlavor > SAL_CALL ChartModel::getTransferDataFlavors()
1112 {
1113     return { datatransfer::DataFlavor( lcl_aGDIMetaFileMIMETypeHighContrast,
1114         u"GDIMetaFile"_ustr,
1115         cppu::UnoType<uno::Sequence< sal_Int8 >>::get() ) };
1116 }
1117
1118 sal_Bool SAL_CALL ChartModel::isDataFlavorSupported( const datatransfer::DataFlavor& aFlavor )
1119 {
1120     return aFlavor.MimeType == lcl_aGDIMetaFileMIMETypeHighContrast;
1121 }
1122
1123 namespace
1124 {
1125 enum eServiceType
1126 {
1127     SERVICE_DASH_TABLE,
1128     SERVICE_GRADIENT_TABLE,
1129     SERVICE_HATCH_TABLE,
1130     SERVICE_BITMAP_TABLE,
1131     SERVICE_TRANSP_GRADIENT_TABLE,
1132     SERVICE_MARKER_TABLE,
1133     SERVICE_NAMESPACE_MAP
1134 };
1135
1136 typedef std::map< OUString, enum eServiceType > tServiceNameMap;
1137
1138 tServiceNameMap & lcl_getStaticServiceNameMap()
1139 {
1140     static tServiceNameMap aServiceNameMap{
1141         {"com.sun.star.drawing.DashTable",                    SERVICE_DASH_TABLE},
1142         {"com.sun.star.drawing.GradientTable",                SERVICE_GRADIENT_TABLE},
1143         {"com.sun.star.drawing.HatchTable",                   SERVICE_HATCH_TABLE},
1144         {"com.sun.star.drawing.BitmapTable",                  SERVICE_BITMAP_TABLE},
1145         {"com.sun.star.drawing.TransparencyGradientTable",    SERVICE_TRANSP_GRADIENT_TABLE},
1146         {"com.sun.star.drawing.MarkerTable",                  SERVICE_MARKER_TABLE},
1147         {"com.sun.star.xml.NamespaceMap",                     SERVICE_NAMESPACE_MAP}};
1148     return aServiceNameMap;
1149 }
1150 }
1151 // ____ XMultiServiceFactory ____
1152 Reference< uno::XInterface > SAL_CALL ChartModel::createInstance( const OUString& rServiceSpecifier )
1153 {
1154     tServiceNameMap & rMap = lcl_getStaticServiceNameMap();
1155
1156     tServiceNameMap::const_iterator aIt( rMap.find( rServiceSpecifier ));
1157     if( aIt != rMap.end())
1158     {
1159         switch( (*aIt).second )
1160         {
1161             case SERVICE_DASH_TABLE:
1162             case SERVICE_GRADIENT_TABLE:
1163             case SERVICE_HATCH_TABLE:
1164             case SERVICE_BITMAP_TABLE:
1165             case SERVICE_TRANSP_GRADIENT_TABLE:
1166             case SERVICE_MARKER_TABLE:
1167                 {
1168                     if(!mxChartView.is())
1169                     {
1170                         mxChartView = new ChartView( m_xContext, *this);
1171                     }
1172                     return mxChartView->createInstance( rServiceSpecifier );
1173                 }
1174                 break;
1175             case SERVICE_NAMESPACE_MAP:
1176                 return static_cast<cppu::OWeakObject*>(m_xXMLNamespaceMap.get());
1177         }
1178     }
1179     else if(rServiceSpecifier == CHART_VIEW_SERVICE_NAME)
1180     {
1181         if(!mxChartView.is())
1182         {
1183             mxChartView = new ChartView( m_xContext, *this);
1184         }
1185
1186         return static_cast< ::cppu::OWeakObject* >( mxChartView.get() );
1187     }
1188     else
1189     {
1190         if( m_xOldModelAgg.is() )
1191         {
1192             Any aAny = m_xOldModelAgg->queryAggregation( cppu::UnoType<lang::XMultiServiceFactory>::get());
1193             uno::Reference< lang::XMultiServiceFactory > xOldModelFactory;
1194             if( (aAny >>= xOldModelFactory) && xOldModelFactory.is() )
1195             {
1196                 return xOldModelFactory->createInstance( rServiceSpecifier );
1197             }
1198         }
1199     }
1200     return nullptr;
1201 }
1202
1203 Reference< uno::XInterface > SAL_CALL ChartModel::createInstanceWithArguments(
1204             const OUString& rServiceSpecifier , const Sequence< Any >& Arguments )
1205 {
1206     OSL_ENSURE( Arguments.hasElements(), "createInstanceWithArguments: Warning: Arguments are ignored" );
1207     return createInstance( rServiceSpecifier );
1208 }
1209
1210 Sequence< OUString > SAL_CALL ChartModel::getAvailableServiceNames()
1211 {
1212     uno::Sequence< OUString > aResult;
1213
1214     if( m_xOldModelAgg.is())
1215     {
1216         Any aAny = m_xOldModelAgg->queryAggregation( cppu::UnoType<lang::XMultiServiceFactory>::get());
1217         uno::Reference< lang::XMultiServiceFactory > xOldModelFactory;
1218         if( (aAny >>= xOldModelFactory) && xOldModelFactory.is() )
1219         {
1220             return xOldModelFactory->getAvailableServiceNames();
1221         }
1222     }
1223     return aResult;
1224 }
1225
1226 Reference< util::XNumberFormatsSupplier > const & ChartModel::getNumberFormatsSupplier()
1227 {
1228     if( !m_xNumberFormatsSupplier.is() )
1229     {
1230         if( !m_xOwnNumberFormatsSupplier.is() )
1231         {
1232             m_apSvNumberFormatter.reset( new SvNumberFormatter( m_xContext, LANGUAGE_SYSTEM ) );
1233             m_xOwnNumberFormatsSupplier = new SvNumberFormatsSupplierObj( m_apSvNumberFormatter.get() );
1234             //pOwnNumberFormatter->ChangeStandardPrec( 15 ); todo?
1235         }
1236         m_xNumberFormatsSupplier = m_xOwnNumberFormatsSupplier;
1237     }
1238     return m_xNumberFormatsSupplier;
1239 }
1240
1241 // ____ XUnoTunnel ___
1242 ::sal_Int64 SAL_CALL ChartModel::getSomething( const Sequence< ::sal_Int8 >& aIdentifier )
1243 {
1244     if( comphelper::isUnoTunnelId<SvNumberFormatsSupplierObj>(aIdentifier) )
1245     {
1246         Reference< lang::XUnoTunnel > xTunnel( getNumberFormatsSupplier(), uno::UNO_QUERY );
1247         if( xTunnel.is() )
1248             return xTunnel->getSomething( aIdentifier );
1249     }
1250     return 0;
1251 }
1252
1253 // ____ XNumberFormatsSupplier ____
1254 uno::Reference< beans::XPropertySet > SAL_CALL ChartModel::getNumberFormatSettings()
1255 {
1256     Reference< util::XNumberFormatsSupplier > xSupplier( getNumberFormatsSupplier() );
1257     if( xSupplier.is() )
1258         return xSupplier->getNumberFormatSettings();
1259     return uno::Reference< beans::XPropertySet >();
1260 }
1261
1262 uno::Reference< util::XNumberFormats > SAL_CALL ChartModel::getNumberFormats()
1263 {
1264     Reference< util::XNumberFormatsSupplier > xSupplier( getNumberFormatsSupplier() );
1265     if( xSupplier.is() )
1266         return xSupplier->getNumberFormats();
1267     return uno::Reference< util::XNumberFormats >();
1268 }
1269
1270 // ____ XChild ____
1271 Reference< uno::XInterface > SAL_CALL ChartModel::getParent()
1272 {
1273     return Reference< uno::XInterface >(m_xParent,uno::UNO_QUERY);
1274 }
1275
1276 void SAL_CALL ChartModel::setParent( const Reference< uno::XInterface >& Parent )
1277 {
1278     if( Parent != m_xParent )
1279         m_xParent.set( Parent, uno::UNO_QUERY );
1280 }
1281
1282 // ____ XDataSource ____
1283 uno::Sequence< Reference< chart2::data::XLabeledDataSequence > > SAL_CALL ChartModel::getDataSequences()
1284 {
1285     rtl::Reference< DataSource > xSource = DataSourceHelper::getUsedData( *this );
1286     if( xSource.is())
1287         return xSource->getDataSequences();
1288
1289     return uno::Sequence< Reference< chart2::data::XLabeledDataSequence > >();
1290 }
1291
1292 //XDumper
1293 OUString SAL_CALL ChartModel::dump(OUString const & kind)
1294 {
1295     if (kind.isEmpty()) {
1296         return comphelper::dumpXmlToString([this](auto writer) { return dumpAsXml(writer); });
1297     }
1298
1299     // kind == "shapes":
1300     uno::Reference< qa::XDumper > xDumper(
1301             createInstance( CHART_VIEW_SERVICE_NAME ), uno::UNO_QUERY );
1302     if (xDumper.is())
1303         return xDumper->dump(kind);
1304
1305     return OUString();
1306 }
1307
1308 void ChartModel::setTimeBasedRange(sal_Int32 nStart, sal_Int32 nEnd)
1309 {
1310     mnStart = nStart;
1311     mnEnd = nEnd;
1312     mbTimeBased = true;
1313 }
1314
1315 void ChartModel::update()
1316 {
1317     if(!mxChartView.is())
1318     {
1319         mxChartView = new ChartView( m_xContext, *this);
1320     }
1321     mxChartView->setViewDirty();
1322     mxChartView->update();
1323 }
1324
1325 bool ChartModel::isDataFromSpreadsheet()
1326 {
1327     return !isDataFromPivotTable() && !hasInternalDataProvider();
1328 }
1329
1330 bool ChartModel::isDataFromPivotTable() const
1331 {
1332     uno::Reference<chart2::data::XPivotTableDataProvider> xPivotTableDataProvider(m_xDataProvider, uno::UNO_QUERY);
1333     return xPivotTableDataProvider.is();
1334 }
1335
1336 }  // namespace chart
1337
1338 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1339 com_sun_star_comp_chart2_ChartModel_get_implementation(css::uno::XComponentContext *context,
1340         css::uno::Sequence<css::uno::Any> const &)
1341 {
1342     return cppu::acquire(new ::chart::ChartModel(context));
1343 }
1344
1345 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */