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