chart2/source/model/main/ChartModel_Persistence.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 <memory>
  21 #include <ChartModel.hxx>
  22 #include <MediaDescriptorHelper.hxx>
  23 #include <ChartViewHelper.hxx>
  24 #include <ChartModelHelper.hxx>
  25 #include <ChartTypeManager.hxx>
  26 #include <ChartTypeTemplate.hxx>
  27 #include <DataSourceHelper.hxx>
  28 #include <AxisHelper.hxx>
  29 #include <ThreeDHelper.hxx>
  30 #include <Diagram.hxx>
  31 #include <BaseCoordinateSystem.hxx>
  32 #include <Legend.hxx>
  33 #include <XMLFilter.hxx>
  34
  35 #include <com/sun/star/chart2/LegendPosition.hpp>
  36 #include <com/sun/star/container/XNameAccess.hpp>
  37 #include <com/sun/star/document/XExporter.hpp>
  38 #include <com/sun/star/document/XImporter.hpp>
  39 #include <com/sun/star/document/XFilter.hpp>
  40 #include <com/sun/star/drawing/FillStyle.hpp>
  41 #include <com/sun/star/drawing/LineStyle.hpp>
  42 #include <com/sun/star/drawing/ProjectionMode.hpp>
  43 #include <com/sun/star/embed/ElementModes.hpp>
  44 #include <com/sun/star/embed/XStorage.hpp>
  45 #include <com/sun/star/embed/StorageFactory.hpp>
  46 #include <com/sun/star/io/IOException.hpp>
  47 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  48 #include <com/sun/star/uno/XComponentContext.hpp>
  49 #include <com/sun/star/ucb/CommandFailedException.hpp>
  50 #include <com/sun/star/ucb/ContentCreationException.hpp>
  51
  52 #include <com/sun/star/chart2/data/XPivotTableDataProvider.hpp>
  53
  54 #include <ucbhelper/content.hxx>
  55 #include <unotools/ucbstreamhelper.hxx>
  56 #include <unotools/tempfile.hxx>
  57 #include <utility>
  58 #include <vcl/cvtgrf.hxx>
  59 #include <comphelper/processfactory.hxx>
  60 #include <comphelper/storagehelper.hxx>
  61 #include <vcl/settings.hxx>
  62 #include <vcl/svapp.hxx>
  63 #include <comphelper/diagnose_ex.hxx>
  64 #include <sal/log.hxx>
  65 #include <sfx2/objsh.hxx>
  66
  67 #include <algorithm>
  68
  69 using namespace ::com::sun::star;
  70
  71 using ::com::sun::star::uno::Reference;
  72 using ::com::sun::star::uno::Sequence;
  73 using ::osl::MutexGuard;
  74
  75 namespace
  76 {
  77 template< typename T >
  78 T lcl_getProperty(
  79     const Sequence< beans::PropertyValue > & rMediaDescriptor,
  80     const OUString & rPropName )
  81 {
  82     T aResult;
  83     if( rMediaDescriptor.hasElements())
  84     {
  85         auto pIt = std::find_if(rMediaDescriptor.begin(), rMediaDescriptor.end(),
  86                                 [&rPropName](auto& prop) { return prop.Name == rPropName; });
  87         if (pIt != rMediaDescriptor.end())
  88             (*pIt).Value >>= aResult;
  89     }
  90     return aResult;
  91 }
  92
  93 void lcl_addStorageToMediaDescriptor(
  94     Sequence< beans::PropertyValue > & rOutMD,
  95     const Reference< embed::XStorage > & xStorage )
  96 {
  97     rOutMD.realloc( rOutMD.getLength() + 1 );
  98     rOutMD.getArray()[rOutMD.getLength() - 1] = beans::PropertyValue(
  99         u"Storage"_ustr, -1, uno::Any( xStorage ), beans::PropertyState_DIRECT_VALUE );
 100 }
 101
 102 Reference< embed::XStorage > lcl_createStorage(
 103     const OUString & rURL,
 104     const Reference< uno::XComponentContext > & xContext,
 105     const Sequence< beans::PropertyValue > & rMediaDescriptor )
 106 {
 107     // create new storage
 108     Reference< embed::XStorage > xStorage;
 109     if( !xContext.is())
 110         return xStorage;
 111
 112     try
 113     {
 114         Reference< io::XStream > xStream(
 115             ::ucbhelper::Content( rURL, Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext()).openStream(),
 116             uno::UNO_QUERY );
 117
 118         Reference< lang::XSingleServiceFactory > xStorageFact( embed::StorageFactory::create( xContext ) );
 119         Sequence< uno::Any > aStorageArgs{ uno::Any(xStream),
 120                                            uno::Any(embed::ElementModes::READWRITE),
 121                                            uno::Any(rMediaDescriptor) };
 122         xStorage.set(
 123             xStorageFact->createInstanceWithArguments( aStorageArgs ), uno::UNO_QUERY_THROW );
 124     }
 125     catch(const css::ucb::ContentCreationException&)
 126     {
 127         DBG_UNHANDLED_EXCEPTION("chart2");
 128     }
 129     catch(const css::ucb::CommandFailedException&)
 130     {
 131         DBG_UNHANDLED_EXCEPTION("chart2");
 132     }
 133
 134     return xStorage;
 135 }
 136
 137 } // anonymous namespace
 138
 139 namespace chart
 140 {
 141
 142 Reference< document::XFilter > ChartModel::impl_createFilter(
 143     const Sequence< beans::PropertyValue > & rMediaDescriptor )
 144 {
 145     Reference< document::XFilter > xFilter;
 146
 147     // find FilterName in MediaDescriptor
 148     OUString aFilterName(
 149         lcl_getProperty< OUString >( rMediaDescriptor, u"FilterName"_ustr ) );
 150
 151     // if FilterName was found, get Filter from factory
 152     if( !aFilterName.isEmpty() )
 153     {
 154         try
 155         {
 156             Reference< container::XNameAccess > xFilterFact(
 157                 m_xContext->getServiceManager()->createInstanceWithContext(
 158                     u"com.sun.star.document.FilterFactory"_ustr, m_xContext ),
 159                 uno::UNO_QUERY_THROW );
 160             uno::Any aFilterProps( xFilterFact->getByName( aFilterName ));
 161             Sequence< beans::PropertyValue > aProps;
 162
 163             if( aFilterProps.hasValue() &&
 164                 (aFilterProps >>= aProps))
 165             {
 166                 OUString aFilterServiceName(
 167                     lcl_getProperty< OUString >( aProps, u"FilterService"_ustr ) );
 168
 169                 if( !aFilterServiceName.isEmpty())
 170                 {
 171                     xFilter.set(
 172                         m_xContext->getServiceManager()->createInstanceWithContext(
 173                             aFilterServiceName, m_xContext ), uno::UNO_QUERY_THROW );
 174                     SAL_INFO("chart2", "Filter found for service " << aFilterServiceName );
 175                 }
 176             }
 177         }
 178         catch( const uno::Exception & )
 179         {
 180             DBG_UNHANDLED_EXCEPTION("chart2");
 181         }
 182         OSL_ENSURE( xFilter.is(), "Filter not found via factory" );
 183     }
 184
 185     // fall-back: create XML-Filter
 186     if( ! xFilter.is())
 187     {
 188         SAL_WARN("chart2", "No FilterName passed in MediaDescriptor" );
 189         xFilter = new XMLFilter(m_xContext);
 190     }
 191
 192     return xFilter;
 193 }
 194
 195 // frame::XStorable2
 196
 197 void SAL_CALL ChartModel::storeSelf( const Sequence< beans::PropertyValue >& rMediaDescriptor )
 198 {
 199     // only some parameters are allowed (see also SfxBaseModel)
 200     // "VersionComment", "Author", "InteractionHandler", "StatusIndicator"
 201     // However, they are ignored here.  They would become interesting when
 202     // charts support a standalone format again.
 203     impl_store( rMediaDescriptor, m_xStorage );
 204 }
 205
 206 // frame::XStorable (base of XStorable2)
 207 sal_Bool SAL_CALL ChartModel::hasLocation()
 208 {
 209     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 210     return !m_aResource.isEmpty();
 211 }
 212
 213 OUString SAL_CALL ChartModel::getLocation()
 214 {
 215     return impl_g_getLocation();
 216 }
 217
 218 sal_Bool SAL_CALL ChartModel::isReadonly()
 219 {
 220     //@todo guard
 221     return m_bReadOnly;
 222 }
 223
 224 void SAL_CALL ChartModel::store()
 225 {
 226     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 227     if(!aGuard.startApiCall(true)) //start LongLastingCall
 228         return; //behave passive if already disposed or closed or throw exception @todo?
 229
 230     OUString aLocation = m_aResource;
 231
 232     if( aLocation.isEmpty() )
 233         throw io::IOException( u"no location specified"_ustr, static_cast< ::cppu::OWeakObject* >(this));
 234     //@todo check whether aLocation is something like private:factory...
 235     if( m_bReadOnly )
 236         throw io::IOException( u"document is read only"_ustr, static_cast< ::cppu::OWeakObject* >(this));
 237
 238     aGuard.clear();
 239
 240     // store
 241     impl_store( m_aMediaDescriptor, m_xStorage );
 242 }
 243
 244 void SAL_CALL ChartModel::storeAsURL(
 245     const OUString& rURL,
 246     const uno::Sequence< beans::PropertyValue >& rMediaDescriptor )
 247 {
 248     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 249     if(!aGuard.startApiCall(true)) //start LongLastingCall
 250         return; //behave passive if already disposed or closed or throw exception @todo?
 251
 252     apphelper::MediaDescriptorHelper aMediaDescriptorHelper(rMediaDescriptor);
 253     const uno::Sequence< beans::PropertyValue >& aReducedMediaDescriptor(
 254         aMediaDescriptorHelper.getReducedForModel() );
 255
 256     m_bReadOnly = false;
 257     aGuard.clear();
 258
 259     // create new storage
 260     Reference< embed::XStorage > xStorage( lcl_createStorage( rURL, m_xContext, aReducedMediaDescriptor ));
 261
 262     if( xStorage.is())
 263     {
 264         impl_store( aReducedMediaDescriptor, xStorage );
 265         attachResource( rURL, aReducedMediaDescriptor );
 266     }
 267 }
 268
 269 void SAL_CALL ChartModel::storeToURL(
 270     const OUString& rURL,
 271     const uno::Sequence< beans::PropertyValue >& rMediaDescriptor )
 272 {
 273     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 274     if(!aGuard.startApiCall(true)) //start LongLastingCall
 275         return; //behave passive if already disposed or closed or throw exception @todo?
 276     //do not change the internal state of the document here
 277
 278     aGuard.clear();
 279
 280     apphelper::MediaDescriptorHelper aMediaDescriptorHelper(rMediaDescriptor);
 281     const uno::Sequence< beans::PropertyValue >& aReducedMediaDescriptor(
 282         aMediaDescriptorHelper.getReducedForModel() );
 283
 284     if ( rURL == "private:stream" )
 285     {
 286         try
 287         {
 288             if( m_xContext.is() && aMediaDescriptorHelper.ISSET_OutputStream )
 289             {
 290                 rtl::Reference< utl::TempFileFastService > xStream = new utl::TempFileFastService;
 291                 Reference< io::XInputStream > xInputStream( xStream->getInputStream());
 292
 293                 Reference< embed::XStorage > xStorage(
 294                     ::comphelper::OStorageHelper::GetStorageFromStream( xStream, embed::ElementModes::READWRITE, m_xContext ));
 295                 if( xStorage.is())
 296                 {
 297                     impl_store( aReducedMediaDescriptor, xStorage );
 298
 299                     xStream->seek( 0 );
 300                     ::comphelper::OStorageHelper::CopyInputToOutput( xInputStream, aMediaDescriptorHelper.OutputStream );
 301                 }
 302             }
 303         }
 304         catch( const uno::Exception & )
 305         {
 306             DBG_UNHANDLED_EXCEPTION("chart2");
 307         }
 308     }
 309     else
 310     {
 311         // create new storage
 312         Reference< embed::XStorage > xStorage( lcl_createStorage( rURL, m_xContext, aReducedMediaDescriptor ));
 313
 314         if( xStorage.is())
 315             impl_store( aReducedMediaDescriptor, xStorage );
 316     }
 317 }
 318
 319 void ChartModel::impl_store(
 320     const Sequence< beans::PropertyValue >& rMediaDescriptor,
 321     const Reference< embed::XStorage > & xStorage )
 322 {
 323     Reference< document::XFilter > xFilter( impl_createFilter( rMediaDescriptor));
 324     if( xFilter.is() && xStorage.is())
 325     {
 326         Sequence< beans::PropertyValue > aMD( rMediaDescriptor );
 327         lcl_addStorageToMediaDescriptor( aMD, xStorage );
 328         try
 329         {
 330             Reference< document::XExporter > xExporter( xFilter, uno::UNO_QUERY_THROW );
 331             xExporter->setSourceDocument( Reference< lang::XComponent >( this ));
 332             xFilter->filter( aMD );
 333         }
 334         catch( const uno::Exception & )
 335         {
 336             DBG_UNHANDLED_EXCEPTION("chart2");
 337         }
 338     }
 339     else
 340     {
 341         OSL_FAIL( "No filter" );
 342     }
 343
 344     setModified( false );
 345
 346     //#i66865#
 347     //for data change notification during chart is not loaded:
 348     //notify parent data provider after saving thus the parent document can store
 349     //the ranges for which a load and update of the chart will be necessary
 350     Reference< beans::XPropertySet > xPropSet( m_xParent, uno::UNO_QUERY );
 351     if ( hasInternalDataProvider() || !xPropSet.is() )
 352         return;
 353
 354     apphelper::MediaDescriptorHelper aMDHelper(rMediaDescriptor);
 355     try
 356     {
 357         xPropSet->setPropertyValue(
 358             u"SavedObject"_ustr,
 359             uno::Any( aMDHelper.HierarchicalDocumentName ) );
 360     }
 361     catch ( const uno::Exception& )
 362     {
 363     }
 364 }
 365
 366 void ChartModel::insertDefaultChart()
 367 {
 368     lockControllers();
 369     createInternalDataProvider( false );
 370     try
 371     {
 372         // create default chart
 373         rtl::Reference< ::chart::ChartTypeTemplate > xTemplate( impl_createDefaultChartTypeTemplate() );
 374         if( xTemplate.is())
 375         {
 376             try
 377             {
 378                 Reference< chart2::data::XDataSource > xDataSource( impl_createDefaultData() );
 379                 Sequence< beans::PropertyValue > aParam;
 380
 381                 bool bSupportsCategories = xTemplate->supportsCategories();
 382                 if( bSupportsCategories )
 383                 {
 384                     aParam = { beans::PropertyValue( u"HasCategories"_ustr, -1, uno::Any( true ),
 385                                                      beans::PropertyState_DIRECT_VALUE ) };
 386                 }
 387
 388                 rtl::Reference< Diagram > xDiagram( xTemplate->createDiagramByDataSource2( xDataSource, aParam ) );
 389
 390                 setFirstDiagram( xDiagram );
 391
 392                 bool bIsRTL = AllSettings::GetMathLayoutRTL();
 393                 //reverse x axis for rtl charts
 394                 if( bIsRTL )
 395                     AxisHelper::setRTLAxisLayout( AxisHelper::getCoordinateSystemByIndex( xDiagram, 0 ) );
 396
 397                 // create and attach legend
 398                 rtl::Reference< Legend > xLegend = new Legend();
 399                 xLegend->setPropertyValue( u"FillStyle"_ustr, uno::Any( drawing::FillStyle_NONE ));
 400                 xLegend->setPropertyValue( u"LineStyle"_ustr, uno::Any( drawing::LineStyle_NONE ));
 401                 xLegend->setPropertyValue( u"LineColor"_ustr, uno::Any( static_cast< sal_Int32 >( 0xb3b3b3 ) ));  // gray30
 402                 xLegend->setPropertyValue( u"FillColor"_ustr, uno::Any( static_cast< sal_Int32 >( 0xe6e6e6 ) ) ); // gray10
 403
 404                 if( bIsRTL )
 405                     xLegend->setPropertyValue( u"AnchorPosition"_ustr, uno::Any( chart2::LegendPosition_LINE_START ));
 406                 if(xDiagram.is())
 407                 {
 408                     xDiagram->setLegend( xLegend );
 409
 410                     // set simple 3D look
 411                     xDiagram->setPropertyValue( u"RightAngledAxes"_ustr, uno::Any( true ));
 412                     xDiagram->setPropertyValue( u"D3DScenePerspective"_ustr, uno::Any( drawing::ProjectionMode_PARALLEL ));
 413                     xDiagram->setScheme( ThreeDLookScheme::ThreeDLookScheme_Realistic );
 414
 415                     //set some new 'defaults' for wall and floor
 416                     Reference< beans::XPropertySet > xWall( xDiagram->getWall() );
 417                     if( xWall.is() )
 418                     {
 419                         xWall->setPropertyValue( u"LineStyle"_ustr, uno::Any( drawing::LineStyle_SOLID ) );
 420                         xWall->setPropertyValue( u"FillStyle"_ustr, uno::Any( drawing::FillStyle_NONE ) );
 421                         xWall->setPropertyValue( u"LineColor"_ustr, uno::Any( static_cast< sal_Int32 >( 0xb3b3b3 ) ) ); // gray30
 422                         xWall->setPropertyValue( u"FillColor"_ustr, uno::Any( static_cast< sal_Int32 >( 0xe6e6e6 ) ) ); // gray10
 423                     }
 424                     Reference< beans::XPropertySet > xFloor( xDiagram->getFloor() );
 425                     if( xFloor.is() )
 426                     {
 427                         xFloor->setPropertyValue( u"LineStyle"_ustr, uno::Any( drawing::LineStyle_NONE ) );
 428                         xFloor->setPropertyValue( u"FillStyle"_ustr, uno::Any( drawing::FillStyle_SOLID ) );
 429                         xFloor->setPropertyValue( u"LineColor"_ustr, uno::Any( static_cast< sal_Int32 >( 0xb3b3b3 ) ) ); // gray30
 430                         xFloor->setPropertyValue( u"FillColor"_ustr, uno::Any( static_cast< sal_Int32 >( 0xcccccc ) ) ); // gray20
 431                     }
 432
 433                 }
 434             }
 435             catch( const uno::Exception & )
 436             {
 437                 DBG_UNHANDLED_EXCEPTION("chart2");
 438             }
 439         }
 440         ChartModelHelper::setIncludeHiddenCells( false, *this );
 441     }
 442     catch( const uno::Exception & )
 443     {
 444         DBG_UNHANDLED_EXCEPTION("chart2");
 445     }
 446     setModified( false );
 447     unlockControllers();
 448 }
 449
 450 // frame::XLoadable
 451 void SAL_CALL ChartModel::initNew()
 452 {
 453 }
 454
 455 void SAL_CALL ChartModel::load(
 456     const Sequence< beans::PropertyValue >& rMediaDescriptor )
 457 {
 458     Reference< embed::XStorage > xStorage;
 459     OUString aURL;
 460     try
 461     {
 462         apphelper::MediaDescriptorHelper aMDHelper( rMediaDescriptor );
 463         if( aMDHelper.ISSET_Storage )
 464         {
 465             xStorage = aMDHelper.Storage;
 466         }
 467         else if( aMDHelper.ISSET_Stream ||
 468                  aMDHelper.ISSET_InputStream )
 469         {
 470             if( aMDHelper.ISSET_FilterName &&
 471                 (aMDHelper.FilterName == "StarChart 5.0" ||
 472                  aMDHelper.FilterName == "StarChart 4.0" ||
 473                  aMDHelper.FilterName == "StarChart 3.0" ))
 474             {
 475                 attachResource( aMDHelper.URL, rMediaDescriptor );
 476                 impl_load( rMediaDescriptor, nullptr ); // cannot create a storage from binary streams, but I do not need the storage here anyhow
 477                 m_bReadOnly = true;
 478                 return;
 479             }
 480
 481             Reference< lang::XSingleServiceFactory > xStorageFact( embed::StorageFactory::create(m_xContext) );
 482
 483             if( aMDHelper.ISSET_Stream )
 484             {
 485                 // convert XStream to XStorage via the storage factory
 486                 Sequence< uno::Any > aStorageArgs{ uno::Any(aMDHelper.Stream),
 487                                                    // todo: check if stream is read-only
 488                                                    uno::Any(embed::ElementModes::READ) }; //WRITE | embed::ElementModes::NOCREATE);
 489
 490                 xStorage.set( xStorageFact->createInstanceWithArguments( aStorageArgs ),
 491                     uno::UNO_QUERY_THROW );
 492             }
 493             else
 494             {
 495                 OSL_ASSERT( aMDHelper.ISSET_InputStream );
 496                 // convert XInputStream to XStorage via the storage factory
 497                 Sequence< uno::Any > aStorageArgs{ uno::Any(aMDHelper.InputStream),
 498                                                    uno::Any(embed::ElementModes::READ) };
 499
 500                 xStorage.set( xStorageFact->createInstanceWithArguments( aStorageArgs ),
 501                     uno::UNO_QUERY_THROW );
 502             }
 503         }
 504
 505         if( aMDHelper.ISSET_URL )
 506             aURL = aMDHelper.URL;
 507     }
 508     catch( const uno::Exception & )
 509     {
 510         DBG_UNHANDLED_EXCEPTION("chart2");
 511     }
 512
 513     if( xStorage.is())
 514     {
 515         attachResource( aURL, rMediaDescriptor );
 516         impl_load( rMediaDescriptor, xStorage );
 517     }
 518 }
 519
 520 void ChartModel::impl_load(
 521     const Sequence< beans::PropertyValue >& rMediaDescriptor,
 522     const Reference< embed::XStorage >& xStorage )
 523 {
 524     {
 525         MutexGuard aGuard( m_aModelMutex );
 526         m_nInLoad++;
 527     }
 528
 529     Reference< document::XFilter > xFilter( impl_createFilter( rMediaDescriptor ));
 530
 531     if( xFilter.is())
 532     {
 533         Reference< document::XImporter > xImporter( xFilter, uno::UNO_QUERY_THROW );
 534         xImporter->setTargetDocument( this );
 535         Sequence< beans::PropertyValue > aMD( rMediaDescriptor );
 536         lcl_addStorageToMediaDescriptor( aMD, xStorage );
 537
 538         xFilter->filter( aMD );
 539         xFilter.clear();
 540     }
 541     else
 542     {
 543         OSL_FAIL( "loadFromStorage cannot create filter" );
 544     }
 545
 546     if( xStorage.is() )
 547         impl_loadGraphics( xStorage );
 548
 549     setModified( false );
 550
 551     // switchToStorage without notifying listeners (which shouldn't exist at
 552     // this time, anyway)
 553     m_xStorage = xStorage;
 554
 555     {
 556         MutexGuard aGuard( m_aModelMutex );
 557         m_nInLoad--;
 558     }
 559 }
 560
 561 void ChartModel::impl_loadGraphics(
 562     const Reference< embed::XStorage >& xStorage )
 563 {
 564     try
 565     {
 566         const Reference< embed::XStorage > xGraphicsStorage(
 567             xStorage->openStorageElement( u"Pictures"_ustr,
 568                                           embed::ElementModes::READ ) );
 569
 570         if( xGraphicsStorage.is() )
 571         {
 572             const uno::Sequence< OUString > aElementNames(
 573                 xGraphicsStorage->getElementNames() );
 574
 575             for( OUString const & streamName : aElementNames )
 576             {
 577                 if( xGraphicsStorage->isStreamElement( streamName ) )
 578                 {
 579                     uno::Reference< io::XStream > xElementStream(
 580                         xGraphicsStorage->openStreamElement(
 581                             streamName,
 582                             embed::ElementModes::READ ) );
 583
 584                     if( xElementStream.is() )
 585                     {
 586                         std::unique_ptr< SvStream > apIStm(
 587                             ::utl::UcbStreamHelper::CreateStream(
 588                                 xElementStream, true ) );
 589
 590                         if (apIStm)
 591                         {
 592                             SolarMutexGuard aGuard;
 593                             Graphic aGraphic;
 594                             if (!GraphicConverter::Import(*apIStm, aGraphic))
 595                             {
 596                                 m_aGraphicObjectVector.emplace_back(aGraphic );
 597                             }
 598                         }
 599                     }
 600                 }
 601             }
 602         }
 603     }
 604     catch ( const uno::Exception& )
 605     {
 606     }
 607 }
 608
 609 // util::XModifiable
 610 void ChartModel::impl_notifyModifiedListeners()
 611 {
 612     {
 613         MutexGuard aGuard( m_aModelMutex );
 614         m_bUpdateNotificationsPending = false;
 615     }
 616
 617     //always notify the view first!
 618     ChartViewHelper::setViewToDirtyState( this );
 619
 620     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 621     if( m_aLifeTimeManager.m_aModifyListeners.getLength(aGuard) )
 622     {
 623         lang::EventObject aEvent( static_cast< lang::XComponent*>(this) );
 624         m_aLifeTimeManager.m_aModifyListeners.notifyEach(aGuard, &util::XModifyListener::modified, aEvent);
 625     }
 626 }
 627
 628 sal_Bool SAL_CALL ChartModel::isModified()
 629 {
 630     //@todo guard
 631     return m_bModified;
 632 }
 633
 634 void SAL_CALL ChartModel::setModified( sal_Bool bModified )
 635 {
 636     // tdf#141914: allow to set *unmodified* when parent does not allow to set modified
 637     if (bModified)
 638     {
 639         // tdf#77007: honor parent's IsEnableSetModified
 640         // Check it before LifeTimeGuard, to avoid deadlocking solar mutex and this guard
 641         if (auto pParentShell = SfxObjectShell::GetShellFromComponent(getParent());
 642             pParentShell && !pParentShell->IsEnableSetModified())
 643             return;
 644     }
 645
 646     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 647     if(!aGuard.startApiCall())//@todo ? is this a long lasting call??
 648         return; //behave passive if already disposed or closed or throw exception @todo?
 649     m_bModified = bModified;
 650
 651     if( m_nControllerLockCount > 0 )
 652     {
 653         if (bModified)
 654             m_bUpdateNotificationsPending = true; // Maybe !bModified should reset it?
 655         return;//don't call listeners if controllers are locked
 656     }
 657     aGuard.clear();
 658
 659     if(bModified)
 660         impl_notifyModifiedListeners();
 661 }
 662
 663 // util::XModifyBroadcaster (base of XModifiable)
 664 void SAL_CALL ChartModel::addModifyListener(
 665     const uno::Reference< util::XModifyListener >& xListener )
 666 {
 667     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 668         return; //behave passive if already disposed or closed
 669
 670     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 671     m_aLifeTimeManager.m_aModifyListeners.addInterface( aGuard, xListener );
 672 }
 673
 674 void SAL_CALL ChartModel::removeModifyListener(
 675     const uno::Reference< util::XModifyListener >& xListener )
 676 {
 677     if( m_aLifeTimeManager.impl_isDisposedOrClosed(false) )
 678         return; //behave passive if already disposed or closed
 679
 680     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 681     m_aLifeTimeManager.m_aModifyListeners.removeInterface( aGuard, xListener );
 682 }
 683
 684 // util::XModifyListener
 685 void SAL_CALL ChartModel::modified( const lang::EventObject& rEvenObject)
 686 {
 687     uno::Reference<chart2::data::XPivotTableDataProvider> xPivotTableDataProvider(rEvenObject.Source, uno::UNO_QUERY);
 688     if (xPivotTableDataProvider.is())
 689     {
 690         lockControllers();
 691         uno::Reference<chart2::data::XDataProvider> xDataProvider(xPivotTableDataProvider, uno::UNO_QUERY);
 692         try
 693         {
 694             uno::Sequence<beans::PropertyValue> aArguments =
 695                 DataSourceHelper::createArguments(u"PivotChart"_ustr, uno::Sequence<sal_Int32>(), true, true, true);
 696
 697             Reference<chart2::data::XDataSource> xDataSource(xDataProvider->createDataSource(aArguments));
 698             rtl::Reference< ::chart::ChartTypeManager > xChartTypeManager = getTypeManager();
 699             rtl::Reference<Diagram> xDiagram(getFirstChartDiagram());
 700
 701             Diagram::tTemplateWithServiceName aTemplateAndService = xDiagram->getTemplate(xChartTypeManager);
 702             aTemplateAndService.xChartTypeTemplate->changeDiagramData(xDiagram, xDataSource, aArguments);
 703         }
 704         catch (const uno::Exception &)
 705         {
 706             DBG_UNHANDLED_EXCEPTION("chart2");
 707         }
 708         unlockControllers();
 709     }
 710
 711     if (m_nInLoad == 0)
 712         setModified(true);
 713 }
 714
 715 // lang::XEventListener (base of util::XModifyListener)
 716 void SAL_CALL ChartModel::disposing( const lang::EventObject& )
 717 {
 718     // child was disposed -- should not happen from outside
 719 }
 720
 721 // document::XStorageBasedDocument
 722 void SAL_CALL ChartModel::loadFromStorage(
 723     const Reference< embed::XStorage >& xStorage,
 724     const Sequence< beans::PropertyValue >& rMediaDescriptor )
 725 {
 726     attachResource( OUString(), rMediaDescriptor );
 727     impl_load( rMediaDescriptor, xStorage );
 728 }
 729
 730 void SAL_CALL ChartModel::storeToStorage(
 731     const Reference< embed::XStorage >& xStorage,
 732     const Sequence< beans::PropertyValue >& rMediaDescriptor )
 733 {
 734     impl_store( rMediaDescriptor, xStorage );
 735 }
 736
 737 void SAL_CALL ChartModel::switchToStorage( const Reference< embed::XStorage >& xStorage )
 738 {
 739     m_xStorage = xStorage;
 740     impl_notifyStorageChangeListeners();
 741 }
 742
 743 Reference< embed::XStorage > SAL_CALL ChartModel::getDocumentStorage()
 744 {
 745     return m_xStorage;
 746 }
 747
 748 void ChartModel::impl_notifyStorageChangeListeners()
 749 {
 750     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 751     if( m_aLifeTimeManager.m_aStorageChangeListeners.getLength(aGuard) )
 752     {
 753         m_aLifeTimeManager.m_aStorageChangeListeners.forEach(aGuard,
 754             [this](const uno::Reference<document::XStorageChangeListener>& l)
 755             {
 756                 l->notifyStorageChange( static_cast< ::cppu::OWeakObject* >( this ), m_xStorage );
 757             });
 758     }
 759 }
 760
 761 void SAL_CALL ChartModel::addStorageChangeListener( const Reference< document::XStorageChangeListener >& xListener )
 762 {
 763     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 764         return; //behave passive if already disposed or closed
 765
 766     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 767     m_aLifeTimeManager.m_aStorageChangeListeners.addInterface( aGuard, xListener );
 768 }
 769
 770 void SAL_CALL ChartModel::removeStorageChangeListener( const Reference< document::XStorageChangeListener >& xListener )
 771 {
 772     if( m_aLifeTimeManager.impl_isDisposedOrClosed(false) )
 773         return; //behave passive if already disposed or closed
 774
 775     std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);
 776     m_aLifeTimeManager.m_aStorageChangeListeners.removeInterface(aGuard, xListener );
 777 }
 778
 779 } //  namespace chart
 780
 781 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */