chart2/source/model/main/ChartModel_Persistence.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ChartModel_Persistence.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33
  34 #include "ChartModel.hxx"
  35 #include "ImplChartModel.hxx"
  36 #include "MediaDescriptorHelper.hxx"
  37 #include "ChartDebugTrace.hxx"
  38 #include "macros.hxx"
  39 #include "ChartViewHelper.hxx"
  40 #include "ChartModelHelper.hxx"
  41 #include <com/sun/star/container/XNameAccess.hpp>
  42 #include <com/sun/star/document/XExporter.hpp>
  43 #include <com/sun/star/document/XImporter.hpp>
  44 #include <com/sun/star/document/XFilter.hpp>
  45 #include <com/sun/star/embed/ElementModes.hpp>
  46 #include <com/sun/star/embed/XStorage.hpp>
  47 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  48 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  49 #include <com/sun/star/uno/XComponentContext.hpp>
  50 #include <com/sun/star/io/XSeekable.hpp>
  51 #include <ucbhelper/content.hxx>
  52 #ifndef _UNOTOOLS_UCBSTREAMHELPER_HXX
  53 #include <unotools/ucbstreamhelper.hxx>
  54 #endif
  55 #include <vcl/cvtgrf.hxx>
  56 #include <comphelper/storagehelper.hxx>
  57
  58 #include <algorithm>
  59 #include <functional>
  60
  61 using namespace ::com::sun::star;
  62
  63 using ::com::sun::star::uno::Reference;
  64 using ::com::sun::star::uno::Sequence;
  65 using ::rtl::OUString;
  66 using ::osl::MutexGuard;
  67
  68 namespace
  69 {
  70 struct lcl_PropNameEquals : public ::std::unary_function< beans::PropertyValue, bool >
  71 {
  72     lcl_PropNameEquals( const OUString & rStrToCompareWith ) :
  73             m_aStr( rStrToCompareWith )
  74     {}
  75     bool operator() ( const beans::PropertyValue & rProp )
  76     {
  77         return rProp.Name.equals( m_aStr );
  78     }
  79 private:
  80     OUString m_aStr;
  81 };
  82
  83 template< typename T >
  84 T lcl_getProperty(
  85     const Sequence< beans::PropertyValue > & rMediaDescriptor,
  86     const OUString & rPropName )
  87 {
  88     T aResult;
  89     if( rMediaDescriptor.getLength())
  90     {
  91         OUString aPropName( rPropName );
  92         const beans::PropertyValue * pIt = rMediaDescriptor.getConstArray();
  93         const beans::PropertyValue * pEndIt = pIt +  + rMediaDescriptor.getLength();
  94         pIt = ::std::find_if( pIt, pEndIt, lcl_PropNameEquals( aPropName ));
  95         if( pIt != pEndIt )
  96             (*pIt).Value >>= aResult;
  97     }
  98     return aResult;
  99 }
 100
 101 void lcl_addStorageToMediaDescriptor(
 102     Sequence< beans::PropertyValue > & rOutMD,
 103     const Reference< embed::XStorage > & xStorage )
 104 {
 105     rOutMD.realloc( rOutMD.getLength() + 1 );
 106     rOutMD[rOutMD.getLength() - 1] = beans::PropertyValue(
 107         C2U("Storage"), -1, uno::makeAny( xStorage ), beans::PropertyState_DIRECT_VALUE );
 108 }
 109
 110 Reference< embed::XStorage > lcl_createStorage(
 111     const OUString & rURL,
 112     const Reference< uno::XComponentContext > & xContext,
 113     const Sequence< beans::PropertyValue > & rMediaDescriptor )
 114 {
 115     // create new storage
 116     Reference< embed::XStorage > xStorage;
 117     if( !xContext.is())
 118         return xStorage;
 119
 120     try
 121     {
 122         Reference< io::XStream > xStream(
 123             ::ucbhelper::Content( rURL, Reference< ::com::sun::star::ucb::XCommandEnvironment >()).openStream(),
 124             uno::UNO_QUERY );
 125
 126         Reference< lang::XSingleServiceFactory > xStorageFact(
 127             xContext->getServiceManager()->createInstanceWithContext(
 128                 C2U("com.sun.star.embed.StorageFactory"),
 129                 xContext ),
 130             uno::UNO_QUERY_THROW );
 131         Sequence< uno::Any > aStorageArgs( 3 );
 132         aStorageArgs[0] <<= xStream;
 133         aStorageArgs[1] <<= embed::ElementModes::READWRITE;
 134         aStorageArgs[2] <<= rMediaDescriptor;
 135         xStorage.set(
 136             xStorageFact->createInstanceWithArguments( aStorageArgs ), uno::UNO_QUERY_THROW );
 137         OSL_ENSURE( xStorage.is(), "No Storage" );
 138     }
 139     catch( ::com::sun::star::ucb::ContentCreationException & rEx )
 140     {
 141         ASSERT_EXCEPTION( rEx );
 142     }
 143
 144     return xStorage;
 145 }
 146
 147 } // anonymous namespace
 148
 149 namespace chart
 150 {
 151
 152 Reference< document::XFilter > ChartModel::impl_createFilter(
 153     const Sequence< beans::PropertyValue > & rMediaDescriptor )
 154 {
 155     Reference< document::XFilter > xFilter;
 156
 157     // find FilterName in MediaDescriptor
 158     OUString aFilterName(
 159         lcl_getProperty< OUString >( rMediaDescriptor, OUString::createFromAscii("FilterName")));
 160
 161     // if FilterName was found, get Filter from factory
 162     if( aFilterName.getLength() > 0 )
 163     {
 164         try
 165         {
 166             Reference< container::XNameAccess > xFilterFact(
 167                 m_xContext->getServiceManager()->createInstanceWithContext(
 168                     C2U( "com.sun.star.document.FilterFactory" ), m_xContext ),
 169                 uno::UNO_QUERY_THROW );
 170             uno::Any aFilterProps( xFilterFact->getByName( aFilterName ));
 171             Sequence< beans::PropertyValue > aProps;
 172
 173             if( aFilterProps.hasValue() &&
 174                 (aFilterProps >>= aProps))
 175             {
 176                 OUString aFilterServiceName(
 177                     lcl_getProperty< OUString >( aProps, OUString::createFromAscii("FilterService")));
 178
 179                 if( aFilterServiceName.getLength())
 180                 {
 181                     xFilter.set(
 182                         m_xContext->getServiceManager()->createInstanceWithContext(
 183                             aFilterServiceName, m_xContext ), uno::UNO_QUERY_THROW );
 184                     OSL_TRACE( "Filter found for service %s", U2C( aFilterServiceName ));
 185                 }
 186             }
 187         }
 188         catch( uno::Exception & ex )
 189         {
 190             ASSERT_EXCEPTION( ex );
 191         }
 192         OSL_ENSURE( xFilter.is(), "Filter not found via factory" );
 193     }
 194
 195     // fall-back: create XML-Filter
 196     if( ! xFilter.is())
 197     {
 198         OSL_TRACE( "No FilterName passed in MediaDescriptor" );
 199         xFilter.set(
 200             m_xContext->getServiceManager()->createInstanceWithContext(
 201                 C2U("com.sun.star.comp.chart2.XMLFilter"), m_xContext ),
 202             uno::UNO_QUERY_THROW );
 203     }
 204
 205     return xFilter;
 206 }
 207
 208 //-----------------------------------------------------------------
 209 // frame::XStorable2
 210 //-----------------------------------------------------------------
 211
 212 void SAL_CALL ChartModel::storeSelf( const Sequence< beans::PropertyValue >& rMediaDescriptor )
 213     throw (lang::IllegalArgumentException,
 214            io::IOException,
 215            uno::RuntimeException)
 216 {
 217     // only some parameters are allowed (see also SfxBaseModel)
 218     // "VersionComment", "Author", "InteractionHandler", "StatusIndicator"
 219     // However, they are ignored here.  They would become interesting when
 220     // charts support a standalone format again.
 221     impl_store( rMediaDescriptor, m_xStorage );
 222 }
 223
 224 //-----------------------------------------------------------------
 225 // frame::XStorable (base of XStorable2)
 226 //-----------------------------------------------------------------
 227 sal_Bool SAL_CALL ChartModel::hasLocation()
 228     throw(uno::RuntimeException)
 229 {
 230     //@todo guard
 231     return m_aResource.getLength()!=0;
 232 }
 233
 234 ::rtl::OUString SAL_CALL ChartModel::getLocation()
 235     throw(uno::RuntimeException)
 236 {
 237     return impl_g_getLocation();
 238 }
 239
 240 sal_Bool SAL_CALL ChartModel::isReadonly()
 241     throw(uno::RuntimeException)
 242 {
 243     //@todo guard
 244     return m_bReadOnly;
 245 }
 246
 247 void SAL_CALL ChartModel::store()
 248     throw(io::IOException,
 249           uno::RuntimeException)
 250 {
 251     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 252     if(!aGuard.startApiCall(sal_True)) //start LongLastingCall
 253         return; //behave passive if already disposed or closed or throw exception @todo?
 254
 255     ::rtl::OUString aLocation = m_aResource;
 256
 257     if( aLocation.getLength() == 0 )
 258         throw io::IOException( C2U( "no location specified" ), static_cast< ::cppu::OWeakObject* >(this));
 259     //@todo check wether aLocation is something like private:factory...
 260     if( m_bReadOnly )
 261         throw io::IOException( C2U( "document is read only" ), static_cast< ::cppu::OWeakObject* >(this));
 262
 263     aGuard.clear();
 264
 265     // store
 266     impl_store( m_aMediaDescriptor, m_xStorage );
 267 }
 268
 269 void SAL_CALL ChartModel::storeAsURL(
 270     const ::rtl::OUString& rURL,
 271     const uno::Sequence< beans::PropertyValue >& rMediaDescriptor )
 272     throw(io::IOException, uno::RuntimeException)
 273 {
 274     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 275     if(!aGuard.startApiCall(sal_True)) //start LongLastingCall
 276         return; //behave passive if already disposed or closed or throw exception @todo?
 277
 278     apphelper::MediaDescriptorHelper aMediaDescriptorHelper(rMediaDescriptor);
 279     uno::Sequence< beans::PropertyValue > aReducedMediaDescriptor(
 280         aMediaDescriptorHelper.getReducedForModel() );
 281
 282     m_bReadOnly = sal_False;
 283     aGuard.clear();
 284
 285     // create new storage
 286     Reference< embed::XStorage > xStorage( lcl_createStorage( rURL, m_xContext, aReducedMediaDescriptor ));
 287
 288     if( xStorage.is())
 289     {
 290         impl_store( aReducedMediaDescriptor, xStorage );
 291         attachResource( rURL, aReducedMediaDescriptor );
 292     }
 293 }
 294
 295 void SAL_CALL ChartModel::storeToURL(
 296     const ::rtl::OUString& rURL,
 297     const uno::Sequence< beans::PropertyValue >& rMediaDescriptor )
 298     throw(io::IOException,
 299           uno::RuntimeException)
 300 {
 301     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 302     if(!aGuard.startApiCall(sal_True)) //start LongLastingCall
 303         return; //behave passive if already disposed or closed or throw exception @todo?
 304     //do not change the internal state of the document here
 305     //...
 306
 307     aGuard.clear();
 308
 309     apphelper::MediaDescriptorHelper aMediaDescriptorHelper(rMediaDescriptor);
 310     uno::Sequence< beans::PropertyValue > aReducedMediaDescriptor(
 311         aMediaDescriptorHelper.getReducedForModel() );
 312
 313     if( rURL.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("private:stream")))
 314     {
 315         try
 316         {
 317             if( m_xContext.is() && aMediaDescriptorHelper.ISSET_OutputStream )
 318             {
 319                 Reference< lang::XMultiServiceFactory > xFact( m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
 320                 Reference< io::XStream > xStream(
 321                     xFact->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.TempFile"))), uno::UNO_QUERY_THROW );
 322                 Reference< io::XInputStream > xInputStream( xStream->getInputStream());
 323
 324                 Reference< embed::XStorage > xStorage(
 325                     ::comphelper::OStorageHelper::GetStorageFromStream( xStream, embed::ElementModes::READWRITE, xFact ));
 326                 if( xStorage.is())
 327                 {
 328                     impl_store( aReducedMediaDescriptor, xStorage );
 329
 330                     Reference< io::XSeekable > xSeekable( xStream, uno::UNO_QUERY_THROW );
 331                     xSeekable->seek( 0 );
 332                     ::comphelper::OStorageHelper::CopyInputToOutput( xInputStream, aMediaDescriptorHelper.OutputStream );
 333                 }
 334             }
 335         }
 336         catch( const uno::Exception & ex )
 337         {
 338             ASSERT_EXCEPTION( ex );
 339         }
 340     }
 341     else
 342     {
 343         // create new storage
 344         Reference< embed::XStorage > xStorage( lcl_createStorage( rURL, m_xContext, aReducedMediaDescriptor ));
 345
 346         if( xStorage.is())
 347             impl_store( aReducedMediaDescriptor, xStorage );
 348     }
 349 }
 350
 351 void ChartModel::impl_store(
 352     const Sequence< beans::PropertyValue >& rMediaDescriptor,
 353     const Reference< embed::XStorage > & xStorage )
 354 {
 355     Reference< document::XFilter > xFilter( impl_createFilter( rMediaDescriptor));
 356     if( xFilter.is() && xStorage.is())
 357     {
 358         Sequence< beans::PropertyValue > aMD( rMediaDescriptor );
 359         lcl_addStorageToMediaDescriptor( aMD, xStorage );
 360         try
 361         {
 362             Reference< document::XExporter > xExporter( xFilter, uno::UNO_QUERY_THROW );
 363             xExporter->setSourceDocument( Reference< lang::XComponent >( this ));
 364             xFilter->filter( aMD );
 365         }
 366         catch( uno::Exception & ex )
 367         {
 368             ASSERT_EXCEPTION( ex );
 369         }
 370     }
 371     else
 372     {
 373         OSL_ENSURE( false, "No filter" );
 374     }
 375
 376     setModified( sal_False );
 377
 378     //#i66865#
 379     //for data change notification during chart is not loaded:
 380     //notify parent data provider after saving thus the parent document can store
 381     //the ranges for which a load and update of the chart will be necessary
 382     Reference< beans::XPropertySet > xPropSet( m_xParent, uno::UNO_QUERY );
 383     if ( !hasInternalDataProvider() && xPropSet.is() )
 384     {
 385         apphelper::MediaDescriptorHelper aMDHelper(rMediaDescriptor);
 386         try
 387         {
 388             xPropSet->setPropertyValue( OUString::createFromAscii("SavedObject"),
 389                 uno::makeAny( aMDHelper.HierarchicalDocumentName ) );
 390         }
 391         catch ( uno::Exception& )
 392         {
 393         }
 394     }
 395 }
 396
 397 //-----------------------------------------------------------------
 398 // frame::XLoadable
 399 //-----------------------------------------------------------------
 400 void SAL_CALL ChartModel::initNew()
 401     throw (frame::DoubleInitializationException,
 402            io::IOException,
 403            uno::Exception,
 404            uno::RuntimeException)
 405 {
 406     lockControllers();
 407     createInternalDataProvider( sal_False );
 408     try
 409     {
 410         m_pImplChartModel->CreateDefaultChart();
 411         ChartModelHelper::setIncludeHiddenCells( false, this );
 412     }
 413     catch( uno::Exception & ex )
 414     {
 415         ASSERT_EXCEPTION( ex );
 416     }
 417     setModified( sal_False );
 418     unlockControllers();
 419
 420 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL
 421     OSL_TRACE( "ChartModel::initNew: Showing ChartDocument structure" );
 422     OSL_TRACE( "----------------------------------------------------" );
 423     debug::ChartDebugTraceDocument( Reference< chart2::XChartDocument >( this ));
 424 #endif
 425 }
 426
 427 void SAL_CALL ChartModel::load(
 428     const Sequence< beans::PropertyValue >& rMediaDescriptor )
 429     throw (frame::DoubleInitializationException,
 430            io::IOException,
 431            uno::Exception,
 432            uno::RuntimeException)
 433 {
 434     Reference< embed::XStorage > xStorage;
 435     OUString aURL;
 436     try
 437     {
 438         apphelper::MediaDescriptorHelper aMDHelper( rMediaDescriptor );
 439         if( aMDHelper.ISSET_Storage )
 440         {
 441             xStorage = aMDHelper.Storage;
 442         }
 443         else if( aMDHelper.ISSET_Stream ||
 444                  aMDHelper.ISSET_InputStream )
 445         {
 446             if( aMDHelper.ISSET_FilterName &&
 447                 (aMDHelper.FilterName.equals( C2U("StarChart 5.0")) ||
 448                  aMDHelper.FilterName.equals( C2U("StarChart 4.0")) ||
 449                  aMDHelper.FilterName.equals( C2U("StarChart 3.0")) ))
 450             {
 451                 attachResource( aMDHelper.URL, rMediaDescriptor );
 452                 impl_load( rMediaDescriptor, 0 ); // cannot create a storage from binary streams, but I do not need the storage here anyhow
 453                 m_bReadOnly = sal_True;
 454                 return;
 455             }
 456
 457             Reference< lang::XSingleServiceFactory > xStorageFact(
 458                 m_xContext->getServiceManager()->createInstanceWithContext(
 459                     C2U("com.sun.star.embed.StorageFactory"),
 460                     m_xContext ),
 461                 uno::UNO_QUERY_THROW );
 462
 463             if( aMDHelper.ISSET_Stream )
 464             {
 465                 // convert XStream to XStorage via the storage factory
 466                 Sequence< uno::Any > aStorageArgs( 2 );
 467                 aStorageArgs[0] <<= aMDHelper.Stream;
 468                 // todo: check if stream is read-only
 469                 aStorageArgs[1] <<= (embed::ElementModes::READ); //WRITE | embed::ElementModes::NOCREATE);
 470
 471                 xStorage.set( xStorageFact->createInstanceWithArguments( aStorageArgs ),
 472                     uno::UNO_QUERY_THROW );
 473             }
 474             else
 475             {
 476                 OSL_ASSERT( aMDHelper.ISSET_InputStream );
 477                 // convert XInputStream to XStorage via the storage factory
 478                 Sequence< uno::Any > aStorageArgs( 2 );
 479                 aStorageArgs[0] <<= aMDHelper.InputStream;
 480                 aStorageArgs[1] <<= (embed::ElementModes::READ);
 481
 482                 xStorage.set( xStorageFact->createInstanceWithArguments( aStorageArgs ),
 483                     uno::UNO_QUERY_THROW );
 484             }
 485         }
 486
 487         if( aMDHelper.ISSET_URL )
 488             aURL = aMDHelper.URL;
 489     }
 490     catch( uno::Exception & ex )
 491     {
 492         ASSERT_EXCEPTION( ex );
 493     }
 494
 495     if( xStorage.is())
 496     {
 497         attachResource( aURL, rMediaDescriptor );
 498         impl_load( rMediaDescriptor, xStorage );
 499     }
 500 }
 501
 502 void ChartModel::impl_load(
 503     const Sequence< beans::PropertyValue >& rMediaDescriptor,
 504     const Reference< embed::XStorage >& xStorage )
 505 {
 506     {
 507         MutexGuard aGuard( m_aModelMutex );
 508         m_nInLoad++;
 509     }
 510
 511     Reference< document::XFilter > xFilter( impl_createFilter( rMediaDescriptor ));
 512
 513     if( xFilter.is())
 514     {
 515         Reference< document::XImporter > xImporter( xFilter, uno::UNO_QUERY_THROW );
 516         xImporter->setTargetDocument( this );
 517         Sequence< beans::PropertyValue > aMD( rMediaDescriptor );
 518         lcl_addStorageToMediaDescriptor( aMD, xStorage );
 519
 520         xFilter->filter( aMD );
 521         xFilter.clear();
 522     }
 523     else
 524     {
 525         OSL_ENSURE( false, "loadFromStorage cannot create filter" );
 526     }
 527
 528     if( xStorage.is() )
 529         impl_loadGraphics( xStorage );
 530
 531     setModified( sal_False );
 532
 533     // switchToStorage without notifying listeners (which shouldn't exist at
 534     // this time, anyway)
 535     m_xStorage = xStorage;
 536
 537     {
 538         MutexGuard aGuard( m_aModelMutex );
 539         m_nInLoad--;
 540     }
 541 }
 542
 543 void ChartModel::impl_loadGraphics(
 544     const Reference< embed::XStorage >& xStorage )
 545 {
 546     try
 547     {
 548         const Reference< embed::XStorage >& xGraphicsStorage(
 549             xStorage->openStorageElement( C2U( "Pictures" ),
 550                                           embed::ElementModes::READ ) );
 551
 552         if( xGraphicsStorage.is() )
 553         {
 554             const uno::Sequence< ::rtl::OUString > aElementNames(
 555                 xGraphicsStorage->getElementNames() );
 556
 557             for( int i = 0; i < aElementNames.getLength(); ++i )
 558             {
 559                 if( xGraphicsStorage->isStreamElement( aElementNames[ i ] ) )
 560                 {
 561                     uno::Reference< io::XStream > xElementStream(
 562                         xGraphicsStorage->openStreamElement(
 563                             aElementNames[ i ],
 564                             embed::ElementModes::READ ) );
 565
 566                     if( xElementStream.is() )
 567                     {
 568                         std::auto_ptr< SvStream > apIStm(
 569                             ::utl::UcbStreamHelper::CreateStream(
 570                                 xElementStream, true ) );
 571
 572                         if( apIStm.get() )
 573                         {
 574                             Graphic aGraphic;
 575
 576                             if( !GraphicConverter::Import(
 577                                     *apIStm.get(),
 578                                     aGraphic ) )
 579                             {
 580                                 m_aGraphicObjectVector.push_back( aGraphic );
 581                             }
 582                         }
 583                     }
 584                 }
 585             }
 586         }
 587     }
 588     catch ( uno::Exception& )
 589     {
 590     }
 591 }
 592
 593 //-----------------------------------------------------------------
 594 // util::XModifiable
 595 //-----------------------------------------------------------------
 596 void SAL_CALL ChartModel::impl_notifyModifiedListeners()
 597     throw( uno::RuntimeException)
 598 {
 599     {
 600         MutexGuard aGuard( m_aModelMutex );
 601         m_bUpdateNotificationsPending = false;
 602     }
 603
 604     //always notify the view first!
 605     ChartViewHelper::setViewToDirtyState( this );
 606
 607     ::cppu::OInterfaceContainerHelper* pIC = m_aLifeTimeManager.m_aListenerContainer
 608         .getContainer( ::getCppuType((const uno::Reference< util::XModifyListener >*)0) );
 609     if( pIC )
 610     {
 611         lang::EventObject aEvent( static_cast< lang::XComponent*>(this) );
 612         ::cppu::OInterfaceIteratorHelper aIt( *pIC );
 613         while( aIt.hasMoreElements() )
 614             (static_cast< util::XModifyListener*>(aIt.next()))->modified( aEvent );
 615     }
 616 }
 617
 618 sal_Bool SAL_CALL ChartModel::isModified()
 619     throw(uno::RuntimeException)
 620 {
 621     //@todo guard
 622     return m_bModified;
 623 }
 624
 625 void SAL_CALL ChartModel::setModified( sal_Bool bModified )
 626     throw(beans::PropertyVetoException,
 627           uno::RuntimeException)
 628 {
 629     apphelper::LifeTimeGuard aGuard(m_aLifeTimeManager);
 630     if(!aGuard.startApiCall())//@todo ? is this a long lasting call??
 631         return; //behave passive if already disposed or closed or throw exception @todo?
 632     m_bModified = bModified;
 633
 634     if( m_nControllerLockCount > 0 )
 635     {
 636         m_bUpdateNotificationsPending = true;
 637         return;//don't call listeners if controllers are locked
 638     }
 639     aGuard.clear();
 640
 641     if(bModified)
 642         impl_notifyModifiedListeners();
 643 }
 644
 645 //-----------------------------------------------------------------
 646 // util::XModifyBroadcaster (base of XModifiable)
 647 //-----------------------------------------------------------------
 648 void SAL_CALL ChartModel::addModifyListener(
 649     const uno::Reference< util::XModifyListener >& xListener )
 650     throw(uno::RuntimeException)
 651 {
 652     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 653         return; //behave passive if already disposed or closed
 654
 655     m_aLifeTimeManager.m_aListenerContainer.addInterface(
 656         ::getCppuType((const uno::Reference< util::XModifyListener >*)0), xListener );
 657 }
 658
 659 void SAL_CALL ChartModel::removeModifyListener(
 660     const uno::Reference< util::XModifyListener >& xListener )
 661     throw(uno::RuntimeException)
 662 {
 663     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 664         return; //behave passive if already disposed or closed
 665
 666     m_aLifeTimeManager.m_aListenerContainer.removeInterface(
 667         ::getCppuType((const uno::Reference< util::XModifyListener >*)0), xListener );
 668 }
 669
 670 //-----------------------------------------------------------------
 671 // util::XModifyListener
 672 //-----------------------------------------------------------------
 673 void SAL_CALL ChartModel::modified( const lang::EventObject& )
 674     throw (uno::RuntimeException)
 675 {
 676     if( m_nInLoad == 0 )
 677         setModified( sal_True );
 678 }
 679
 680 //-----------------------------------------------------------------
 681 // lang::XEventListener (base of util::XModifyListener)
 682 //-----------------------------------------------------------------
 683 void SAL_CALL ChartModel::disposing( const lang::EventObject& )
 684     throw (uno::RuntimeException)
 685 {
 686     // child was disposed -- should not happen from outside
 687 }
 688
 689
 690 //-----------------------------------------------------------------
 691 // document::XStorageBasedDocument
 692 //-----------------------------------------------------------------
 693 void SAL_CALL ChartModel::loadFromStorage(
 694     const Reference< embed::XStorage >& xStorage,
 695     const Sequence< beans::PropertyValue >& rMediaDescriptor )
 696     throw (lang::IllegalArgumentException,
 697            frame::DoubleInitializationException,
 698            io::IOException,
 699            uno::Exception,
 700            uno::RuntimeException)
 701 {
 702     attachResource( OUString(), rMediaDescriptor );
 703     impl_load( rMediaDescriptor, xStorage );
 704 }
 705
 706 void SAL_CALL ChartModel::storeToStorage(
 707     const Reference< embed::XStorage >& xStorage,
 708     const Sequence< beans::PropertyValue >& rMediaDescriptor )
 709     throw (lang::IllegalArgumentException,
 710            io::IOException,
 711            uno::Exception,
 712            uno::RuntimeException)
 713 {
 714     impl_store( rMediaDescriptor, xStorage );
 715 }
 716
 717 void SAL_CALL ChartModel::switchToStorage( const Reference< embed::XStorage >& xStorage )
 718     throw (lang::IllegalArgumentException,
 719            io::IOException,
 720            uno::Exception,
 721            uno::RuntimeException)
 722 {
 723     m_xStorage = xStorage;
 724     impl_notifyStorageChangeListeners();
 725 }
 726
 727 Reference< embed::XStorage > SAL_CALL ChartModel::getDocumentStorage()
 728     throw (io::IOException,
 729            uno::Exception,
 730            uno::RuntimeException)
 731 {
 732     return m_xStorage;
 733 }
 734
 735 void SAL_CALL ChartModel::impl_notifyStorageChangeListeners()
 736     throw( uno::RuntimeException)
 737 {
 738     ::cppu::OInterfaceContainerHelper* pIC = m_aLifeTimeManager.m_aListenerContainer
 739           .getContainer( ::getCppuType((const uno::Reference< document::XStorageChangeListener >*)0) );
 740     if( pIC )
 741     {
 742         ::cppu::OInterfaceIteratorHelper aIt( *pIC );
 743         while( aIt.hasMoreElements() )
 744             (static_cast< document::XStorageChangeListener* >(aIt.next()))->notifyStorageChange(
 745                 static_cast< ::cppu::OWeakObject* >( this ), m_xStorage );
 746     }
 747 }
 748
 749 void SAL_CALL ChartModel::addStorageChangeListener( const Reference< document::XStorageChangeListener >& xListener )
 750     throw (uno::RuntimeException)
 751 {
 752     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 753         return; //behave passive if already disposed or closed
 754
 755     m_aLifeTimeManager.m_aListenerContainer.addInterface(
 756         ::getCppuType((const uno::Reference< document::XStorageChangeListener >*)0), xListener );
 757 }
 758
 759 void SAL_CALL ChartModel::removeStorageChangeListener( const Reference< document::XStorageChangeListener >& xListener )
 760     throw (uno::RuntimeException)
 761 {
 762     if( m_aLifeTimeManager.impl_isDisposedOrClosed() )
 763         return; //behave passive if already disposed or closed
 764
 765     m_aLifeTimeManager.m_aListenerContainer.removeInterface(
 766         ::getCppuType((const uno::Reference< document::XStorageChangeListener >*)0), xListener );
 767 }
 768
 769 } //  namespace chart