reportdesign/source/core/sdr/UndoEnv.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 #include "UndoActions.hxx"
  20 #include "UndoEnv.hxx"
  21 #include "formatnormalizer.hxx"
  22 #include "conditionupdater.hxx"
  23 #include "corestrings.hrc"
  24 #include "rptui_slotid.hrc"
  25 #include "RptDef.hxx"
  26 #include "ModuleHelper.hxx"
  27 #include "RptObject.hxx"
  28 #include "RptPage.hxx"
  29 #include "RptResId.hrc"
  30 #include "RptModel.hxx"
  31
  32 #include <boost/noncopyable.hpp>
  33 #include <com/sun/star/script/XEventAttacherManager.hpp>
  34 #include <com/sun/star/container/XChild.hpp>
  35 #include <com/sun/star/container/XNameContainer.hpp>
  36 #include <com/sun/star/beans/theIntrospection.hpp>
  37 #include <com/sun/star/beans/PropertyAttribute.hpp>
  38 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  39 #include <com/sun/star/beans/XIntrospectionAccess.hpp>
  40 #include <com/sun/star/beans/XIntrospection.hpp>
  41
  42 #include <connectivity/dbtools.hxx>
  43 #include <svl/smplhint.hxx>
  44 #include <tools/diagnose_ex.h>
  45 #include <comphelper/stl_types.hxx>
  46 #include <vcl/svapp.hxx>
  47 #include <dbaccess/dbsubcomponentcontroller.hxx>
  48 #include <svx/unoshape.hxx>
  49 #include <osl/mutex.hxx>
  50
  51 namespace rptui
  52 {
  53     using namespace ::com::sun::star;
  54     using namespace uno;
  55     using namespace lang;
  56     using namespace script;
  57     using namespace beans;
  58     using namespace awt;
  59     using namespace util;
  60     using namespace container;
  61     using namespace report;
  62
  63
  64
  65 struct PropertyInfo
  66 {
  67     bool    bIsReadonlyOrTransient;
  68
  69     PropertyInfo( const bool i_bIsTransientOrReadOnly )
  70         :bIsReadonlyOrTransient( i_bIsTransientOrReadOnly )
  71     {
  72     }
  73 };
  74
  75 typedef std::unordered_map< OUString, PropertyInfo, OUStringHash >    PropertiesInfo;
  76
  77 struct ObjectInfo
  78 {
  79     PropertiesInfo              aProperties;
  80     Reference< XPropertySet >   xPropertyIntrospection;
  81
  82     ObjectInfo()
  83         :aProperties()
  84         ,xPropertyIntrospection()
  85     {
  86     }
  87 };
  88
  89 typedef ::std::map< Reference< XPropertySet >, ObjectInfo, ::comphelper::OInterfaceCompare< XPropertySet > >    PropertySetInfoCache;
  90
  91
  92
  93 class OXUndoEnvironmentImpl: private boost::noncopyable
  94 {
  95 public:
  96     OReportModel&                                       m_rModel;
  97     PropertySetInfoCache                                m_aPropertySetCache;
  98     FormatNormalizer                                    m_aFormatNormalizer;
  99     ConditionUpdater                                    m_aConditionUpdater;
 100     ::osl::Mutex                                        m_aMutex;
 101     ::std::vector< uno::Reference< container::XChild> > m_aSections;
 102     Reference< XIntrospection >                         m_xIntrospection;
 103     oslInterlockedCount                                 m_nLocks;
 104     bool                                            m_bReadOnly;
 105     bool                                            m_bIsUndo;
 106
 107     OXUndoEnvironmentImpl(OReportModel& _rModel);
 108 };
 109
 110 OXUndoEnvironmentImpl::OXUndoEnvironmentImpl(OReportModel& _rModel) : m_rModel(_rModel)
 111         ,m_aFormatNormalizer( _rModel )
 112         ,m_aConditionUpdater()
 113         ,m_nLocks(0)
 114         ,m_bReadOnly(false)
 115         ,m_bIsUndo(false)
 116 {
 117 }
 118
 119
 120
 121 OXUndoEnvironment::OXUndoEnvironment(OReportModel& _rModel)
 122                    :m_pImpl(new OXUndoEnvironmentImpl(_rModel) )
 123 {
 124     StartListening(m_pImpl->m_rModel);
 125 }
 126
 127
 128 OXUndoEnvironment::~OXUndoEnvironment()
 129 {
 130 }
 131
 132 void OXUndoEnvironment::Lock()
 133 {
 134     OSL_ENSURE(m_refCount,"Illegal call to dead object!");
 135     osl_atomic_increment( &m_pImpl->m_nLocks );
 136 }
 137 void OXUndoEnvironment::UnLock()
 138 {
 139     OSL_ENSURE(m_refCount,"Illegal call to dead object!");
 140
 141     osl_atomic_decrement( &m_pImpl->m_nLocks );
 142 }
 143 bool OXUndoEnvironment::IsLocked() const { return m_pImpl->m_nLocks != 0; }
 144
 145 void OXUndoEnvironment::RemoveSection(OReportPage* _pPage)
 146 {
 147     if ( _pPage )
 148     {
 149         Reference< XInterface > xSection(_pPage->getSection());
 150         if ( xSection.is() )
 151             RemoveElement( xSection );
 152     }
 153 }
 154
 155 void OXUndoEnvironment::Clear(const Accessor& /*_r*/)
 156 {
 157     OUndoEnvLock aLock(*this);
 158
 159     m_pImpl->m_aPropertySetCache.clear();
 160
 161     sal_uInt16 nCount = m_pImpl->m_rModel.GetPageCount();
 162     sal_uInt16 i;
 163     for (i = 0; i < nCount; i++)
 164     {
 165         OReportPage* pPage = PTR_CAST( OReportPage, m_pImpl->m_rModel.GetPage(i) );
 166         RemoveSection(pPage);
 167     }
 168
 169     nCount = m_pImpl->m_rModel.GetMasterPageCount();
 170     for (i = 0; i < nCount; i++)
 171     {
 172         OReportPage* pPage = PTR_CAST( OReportPage, m_pImpl->m_rModel.GetMasterPage(i) );
 173         RemoveSection(pPage);
 174     }
 175
 176     m_pImpl->m_aSections.clear();
 177
 178     if (IsListening(m_pImpl->m_rModel))
 179         EndListening(m_pImpl->m_rModel);
 180 }
 181
 182
 183 void OXUndoEnvironment::ModeChanged()
 184 {
 185     m_pImpl->m_bReadOnly = !m_pImpl->m_bReadOnly;
 186
 187     if (!m_pImpl->m_bReadOnly)
 188         StartListening(m_pImpl->m_rModel);
 189     else
 190         EndListening(m_pImpl->m_rModel);
 191 }
 192
 193
 194 void OXUndoEnvironment::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
 195 {
 196     const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
 197     if (pSimpleHint && pSimpleHint->GetId() == SFX_HINT_MODECHANGED )
 198         ModeChanged();
 199 }
 200
 201 //  XEventListener
 202
 203 void SAL_CALL OXUndoEnvironment::disposing(const EventObject& e) throw( RuntimeException, std::exception )
 204 {
 205     // check if it's an object we have cached information about
 206     Reference< XPropertySet > xSourceSet(e.Source, UNO_QUERY);
 207     if ( xSourceSet.is() )
 208     {
 209         uno::Reference< report::XSection> xSection(xSourceSet,uno::UNO_QUERY);
 210         if ( xSection.is() )
 211             RemoveSection(xSection);
 212         else
 213             RemoveElement(xSourceSet);
 214     }
 215 }
 216
 217 // XPropertyChangeListener
 218
 219 void SAL_CALL OXUndoEnvironment::propertyChange( const PropertyChangeEvent& _rEvent ) throw(uno::RuntimeException, std::exception)
 220 {
 221
 222     ::osl::ClearableMutexGuard aGuard( m_pImpl->m_aMutex );
 223
 224     if ( IsLocked() )
 225         return;
 226
 227     Reference< XPropertySet >  xSet( _rEvent.Source, UNO_QUERY );
 228     if (!xSet.is())
 229         return;
 230
 231     dbaui::DBSubComponentController* pController = m_pImpl->m_rModel.getController();
 232     if ( !pController )
 233         return;
 234
 235     // no Undo for transient and readonly props.
 236     // let's see if we know something about the set
 237     PropertySetInfoCache::iterator objectPos = m_pImpl->m_aPropertySetCache.find(xSet);
 238     if (objectPos == m_pImpl->m_aPropertySetCache.end())
 239     {
 240         objectPos = m_pImpl->m_aPropertySetCache.insert( PropertySetInfoCache::value_type(
 241             xSet, ObjectInfo()
 242         ) ).first;
 243         DBG_ASSERT(objectPos != m_pImpl->m_aPropertySetCache.end(), "OXUndoEnvironment::propertyChange : just inserted it ... why it's not there ?");
 244     }
 245     if ( objectPos == m_pImpl->m_aPropertySetCache.end() )
 246         return;
 247
 248     // now we have access to the cached info about the set
 249     // let's see what we know about the property
 250     ObjectInfo& rObjectInfo = objectPos->second;
 251     PropertiesInfo::iterator aPropertyPos = rObjectInfo.aProperties.find( _rEvent.PropertyName );
 252     if ( aPropertyPos == rObjectInfo.aProperties.end() )
 253     {   // nothing 'til now ... have to change this ....
 254         // the attributes
 255         Reference< XPropertySetInfo > xPSI( xSet->getPropertySetInfo(), UNO_SET_THROW );
 256         sal_Int32 nPropertyAttributes = 0;
 257         try
 258         {
 259             if ( xPSI->hasPropertyByName( _rEvent.PropertyName ) )
 260             {
 261                 nPropertyAttributes = xPSI->getPropertyByName( _rEvent.PropertyName ).Attributes;
 262             }
 263             else
 264             {
 265                 // it's perfectly valid for a component to notify a change in a property which it doesn't have - as long
 266                 // as it has an attribute with this name
 267                 if ( !rObjectInfo.xPropertyIntrospection.is() )
 268                 {
 269                     if ( !m_pImpl->m_xIntrospection.is() )
 270                     {
 271                         m_pImpl->m_xIntrospection = theIntrospection::get( m_pImpl->m_rModel.getController()->getORB() );
 272                     }
 273                     Reference< XIntrospectionAccess > xIntrospection(
 274                         m_pImpl->m_xIntrospection->inspect( makeAny( _rEvent.Source ) ),
 275                         UNO_SET_THROW
 276                     );
 277                     rObjectInfo.xPropertyIntrospection.set( xIntrospection->queryAdapter( cppu::UnoType<XPropertySet>::get() ), UNO_QUERY_THROW );
 278                 }
 279                 if ( rObjectInfo.xPropertyIntrospection.is() )
 280                 {
 281                     xPSI.set( rObjectInfo.xPropertyIntrospection->getPropertySetInfo(), UNO_SET_THROW );
 282                     nPropertyAttributes = xPSI->getPropertyByName( _rEvent.PropertyName ).Attributes;
 283                 }
 284             }
 285         }
 286         catch( const Exception& )
 287         {
 288             DBG_UNHANDLED_EXCEPTION();
 289         }
 290         const bool bTransReadOnly =
 291                     ( ( nPropertyAttributes & PropertyAttribute::READONLY ) != 0 )
 292                 ||  ( ( nPropertyAttributes & PropertyAttribute::TRANSIENT ) != 0 );
 293
 294         // insert the new entry
 295         aPropertyPos = rObjectInfo.aProperties.insert( PropertiesInfo::value_type(
 296             _rEvent.PropertyName,
 297             PropertyInfo( bTransReadOnly )
 298         ) ).first;
 299         DBG_ASSERT(aPropertyPos != rObjectInfo.aProperties.end(), "OXUndoEnvironment::propertyChange : just inserted it ... why it's not there ?");
 300     }
 301
 302     implSetModified();
 303
 304     // now we have access to the cached info about the property affected
 305     // and are able to decide whether or not we need an undo action
 306
 307     // no UNDO for transient/readonly properties
 308     if ( aPropertyPos->second.bIsReadonlyOrTransient )
 309         return;
 310
 311     // give components with sub responsibilities a chance
 312     m_pImpl->m_aFormatNormalizer.notifyPropertyChange( _rEvent );
 313     m_pImpl->m_aConditionUpdater.notifyPropertyChange( _rEvent );
 314
 315     aGuard.clear();
 316     // TODO: this is a potential race condition: two threads here could in theory
 317     // add their undo actions out-of-order
 318
 319     SolarMutexGuard aSolarGuard;
 320     ORptUndoPropertyAction* pUndo = NULL;
 321     try
 322     {
 323         uno::Reference< report::XSection> xSection( xSet, uno::UNO_QUERY );
 324         if ( xSection.is() )
 325         {
 326             uno::Reference< report::XGroup> xGroup = xSection->getGroup();
 327             if ( xGroup.is() )
 328                 pUndo = new OUndoPropertyGroupSectionAction( m_pImpl->m_rModel, _rEvent, OGroupHelper::getMemberFunction( xSection ), xGroup );
 329             else
 330                 pUndo = new OUndoPropertyReportSectionAction( m_pImpl->m_rModel, _rEvent, OReportHelper::getMemberFunction( xSection ), xSection->getReportDefinition() );
 331         }
 332     }
 333     catch(const Exception&)
 334     {
 335         DBG_UNHANDLED_EXCEPTION();
 336     }
 337
 338     if ( pUndo == NULL )
 339         pUndo = new ORptUndoPropertyAction( m_pImpl->m_rModel, _rEvent );
 340
 341     m_pImpl->m_rModel.GetSdrUndoManager()->AddUndoAction( pUndo );
 342     pController->InvalidateAll();
 343 }
 344
 345 ::std::vector< uno::Reference< container::XChild> >::const_iterator OXUndoEnvironment::getSection(const Reference<container::XChild>& _xContainer) const
 346 {
 347     ::std::vector< uno::Reference< container::XChild> >::const_iterator aFind = m_pImpl->m_aSections.end();
 348     if ( _xContainer.is() )
 349     {
 350         aFind = ::std::find(m_pImpl->m_aSections.begin(),m_pImpl->m_aSections.end(),_xContainer);
 351
 352         if ( aFind == m_pImpl->m_aSections.end() )
 353         {
 354             Reference<container::XChild> xParent(_xContainer->getParent(),uno::UNO_QUERY);
 355             aFind = getSection(xParent);
 356         }
 357     }
 358     return aFind;
 359 }
 360 // XContainerListener
 361
 362 void SAL_CALL OXUndoEnvironment::elementInserted(const ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
 363 {
 364     SolarMutexGuard aSolarGuard;
 365     ::osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 366
 367     // neues Object zum lauschen
 368     Reference< uno::XInterface >  xIface( evt.Element, UNO_QUERY );
 369     if ( !IsLocked() )
 370     {
 371         Reference< report::XReportComponent >  xReportComponent( xIface, UNO_QUERY );
 372         if ( xReportComponent.is() )
 373         {
 374             Reference< report::XSection > xContainer(evt.Source,uno::UNO_QUERY);
 375
 376             ::std::vector< uno::Reference< container::XChild> >::const_iterator aFind = getSection(xContainer.get());
 377
 378             if ( aFind != m_pImpl->m_aSections.end() )
 379             {
 380                 OUndoEnvLock aLock(*this);
 381                 try
 382                 {
 383                     OReportPage* pPage = m_pImpl->m_rModel.getPage(uno::Reference< report::XSection>(*aFind,uno::UNO_QUERY));
 384                     OSL_ENSURE(pPage,"No page could be found for section!");
 385                     if ( pPage )
 386                         pPage->insertObject(xReportComponent);
 387                 }
 388                 catch(uno::Exception&)
 389                 {
 390                     DBG_UNHANDLED_EXCEPTION();
 391                 }
 392
 393             }
 394         }
 395         else
 396         {
 397             uno::Reference< report::XFunctions> xContainer(evt.Source,uno::UNO_QUERY);
 398             if ( xContainer.is() )
 399             {
 400                 m_pImpl->m_rModel.GetSdrUndoManager()->AddUndoAction(
 401                     new OUndoContainerAction( m_pImpl->m_rModel, rptui::Inserted, xContainer.get(),
 402                         xIface, RID_STR_UNDO_ADDFUNCTION ) );
 403             }
 404         }
 405     }
 406
 407     AddElement(xIface);
 408
 409     implSetModified();
 410 }
 411
 412
 413 void OXUndoEnvironment::implSetModified()
 414 {
 415     m_pImpl->m_rModel.SetModified( true );
 416 }
 417
 418
 419 void SAL_CALL OXUndoEnvironment::elementReplaced(const ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
 420 {
 421     SolarMutexGuard aSolarGuard;
 422     ::osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 423
 424     Reference< XInterface >  xIface(evt.ReplacedElement,uno::UNO_QUERY);
 425     OSL_ENSURE(xIface.is(), "OXUndoEnvironment::elementReplaced: invalid container notification!");
 426     RemoveElement(xIface);
 427
 428     xIface.set(evt.Element,uno::UNO_QUERY);
 429     AddElement(xIface);
 430
 431     implSetModified();
 432 }
 433
 434
 435 void SAL_CALL OXUndoEnvironment::elementRemoved(const ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
 436 {
 437     SolarMutexGuard aSolarGuard;
 438     ::osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 439
 440     Reference< uno::XInterface >  xIface( evt.Element, UNO_QUERY );
 441     if ( !IsLocked() )
 442     {
 443         Reference< report::XSection > xContainer(evt.Source,uno::UNO_QUERY);
 444         ::std::vector< uno::Reference< container::XChild> >::const_iterator aFind = getSection(xContainer.get());
 445
 446         Reference< report::XReportComponent >  xReportComponent( xIface, UNO_QUERY );
 447         if ( aFind != m_pImpl->m_aSections.end() && xReportComponent.is() )
 448         {
 449             OXUndoEnvironment::OUndoEnvLock aLock(*this);
 450             try
 451             {
 452                 OReportPage* pPage = m_pImpl->m_rModel.getPage(uno::Reference< report::XSection >( *aFind, uno::UNO_QUERY_THROW ) );
 453                 OSL_ENSURE( pPage, "OXUndoEnvironment::elementRemoved: no page for the section!" );
 454                 if ( pPage )
 455                     pPage->removeSdrObject(xReportComponent);
 456             }
 457             catch(const uno::Exception&)
 458             {
 459                 DBG_UNHANDLED_EXCEPTION();
 460             }
 461         }
 462         else
 463         {
 464             uno::Reference< report::XFunctions> xFunctions(evt.Source,uno::UNO_QUERY);
 465             if ( xFunctions.is() )
 466             {
 467                 m_pImpl->m_rModel.GetSdrUndoManager()->AddUndoAction( new OUndoContainerAction(
 468                     m_pImpl->m_rModel, rptui::Removed, xFunctions.get(), xIface, RID_STR_UNDO_ADDFUNCTION ) );
 469             }
 470         }
 471     }
 472
 473     if ( xIface.is() )
 474         RemoveElement(xIface);
 475
 476     implSetModified();
 477 }
 478
 479
 480 void SAL_CALL OXUndoEnvironment::modified( const EventObject& /*aEvent*/ ) throw (RuntimeException, std::exception)
 481 {
 482     implSetModified();
 483 }
 484
 485
 486 void OXUndoEnvironment::AddSection(const Reference< report::XSection > & _xSection)
 487 {
 488     OUndoEnvLock aLock(*this);
 489     try
 490     {
 491         uno::Reference<container::XChild> xChild = _xSection.get();
 492         uno::Reference<report::XGroup> xGroup(xChild->getParent(),uno::UNO_QUERY);
 493         m_pImpl->m_aSections.push_back(xChild);
 494         Reference< XInterface >  xInt(_xSection);
 495         AddElement(xInt);
 496     }
 497     catch(const uno::Exception&)
 498     {
 499         DBG_UNHANDLED_EXCEPTION();
 500     }
 501 }
 502
 503
 504 void OXUndoEnvironment::RemoveSection(const Reference< report::XSection > & _xSection)
 505 {
 506     OUndoEnvLock aLock(*this);
 507     try
 508     {
 509         uno::Reference<container::XChild> xChild(_xSection.get());
 510         m_pImpl->m_aSections.erase(::std::remove(m_pImpl->m_aSections.begin(),m_pImpl->m_aSections.end(),
 511             xChild), m_pImpl->m_aSections.end());
 512         Reference< XInterface >  xInt(_xSection);
 513         RemoveElement(xInt);
 514     }
 515     catch(uno::Exception&){}
 516 }
 517
 518
 519 void OXUndoEnvironment::TogglePropertyListening(const Reference< XInterface > & Element)
 520 {
 521     // am Container horchen
 522     Reference< XIndexAccess >  xContainer(Element, UNO_QUERY);
 523     if (xContainer.is())
 524     {
 525         Reference< XInterface > xInterface;
 526         sal_Int32 nCount = xContainer->getCount();
 527         for(sal_Int32 i = 0;i != nCount;++i)
 528         {
 529             xInterface.set(xContainer->getByIndex( i ),uno::UNO_QUERY);
 530             TogglePropertyListening(xInterface);
 531         }
 532     }
 533
 534     Reference< XPropertySet >  xSet(Element, UNO_QUERY);
 535     if (xSet.is())
 536     {
 537         if (!m_pImpl->m_bReadOnly)
 538             xSet->addPropertyChangeListener( OUString(), this );
 539         else
 540             xSet->removePropertyChangeListener( OUString(), this );
 541     }
 542 }
 543
 544
 545
 546 void OXUndoEnvironment::switchListening( const Reference< XIndexAccess >& _rxContainer, bool _bStartListening )
 547 {
 548     OSL_PRECOND( _rxContainer.is(), "OXUndoEnvironment::switchListening: invalid container!" );
 549     if ( !_rxContainer.is() )
 550         return;
 551
 552     try
 553     {
 554         // also handle all children of this element
 555         Reference< XInterface > xInterface;
 556         sal_Int32 nCount = _rxContainer->getCount();
 557         for(sal_Int32 i = 0;i != nCount;++i)
 558         {
 559             xInterface.set(_rxContainer->getByIndex( i ),uno::UNO_QUERY);
 560             if ( _bStartListening )
 561                 AddElement( xInterface );
 562             else
 563                 RemoveElement( xInterface );
 564         }
 565
 566         // be notified of any changes in the container elements
 567         Reference< XContainer > xSimpleContainer( _rxContainer, UNO_QUERY );
 568         if ( xSimpleContainer.is() )
 569         {
 570             if ( _bStartListening )
 571                 xSimpleContainer->addContainerListener( this );
 572             else
 573                 xSimpleContainer->removeContainerListener( this );
 574         }
 575     }
 576     catch( const Exception& )
 577     {
 578         DBG_UNHANDLED_EXCEPTION();
 579     }
 580 }
 581
 582
 583 void OXUndoEnvironment::switchListening( const Reference< XInterface >& _rxObject, bool _bStartListening )
 584 {
 585     OSL_PRECOND( _rxObject.is(), "OXUndoEnvironment::switchListening: how should I listen at a NULL object?" );
 586
 587     try
 588     {
 589         if ( !m_pImpl->m_bReadOnly )
 590         {
 591             Reference< XPropertySet > xProps( _rxObject, UNO_QUERY );
 592             if ( xProps.is() )
 593             {
 594                 if ( _bStartListening )
 595                     xProps->addPropertyChangeListener( OUString(), this );
 596                 else
 597                     xProps->removePropertyChangeListener( OUString(), this );
 598             }
 599         }
 600
 601         Reference< XModifyBroadcaster > xBroadcaster( _rxObject, UNO_QUERY );
 602         if ( xBroadcaster.is() )
 603         {
 604             if ( _bStartListening )
 605                 xBroadcaster->addModifyListener( this );
 606             else
 607                 xBroadcaster->removeModifyListener( this );
 608         }
 609     }
 610     catch( const Exception& )
 611     {
 612     }
 613 }
 614
 615
 616 void OXUndoEnvironment::AddElement(const Reference< XInterface >& _rxElement )
 617 {
 618     if ( !IsLocked() )
 619         m_pImpl->m_aFormatNormalizer.notifyElementInserted( _rxElement );
 620
 621     // if it's a container, start listening at all elements
 622     Reference< XIndexAccess > xContainer( _rxElement, UNO_QUERY );
 623     if ( xContainer.is() )
 624         switchListening( xContainer, true );
 625
 626     switchListening( _rxElement, true );
 627 }
 628
 629
 630 void OXUndoEnvironment::RemoveElement(const Reference< XInterface >& _rxElement)
 631 {
 632     uno::Reference<beans::XPropertySet> xProp(_rxElement,uno::UNO_QUERY);
 633     if (!m_pImpl->m_aPropertySetCache.empty())
 634         m_pImpl->m_aPropertySetCache.erase(xProp);
 635     switchListening( _rxElement, false );
 636
 637     Reference< XIndexAccess > xContainer( _rxElement, UNO_QUERY );
 638     if ( xContainer.is() )
 639         switchListening( xContainer, false );
 640 }
 641
 642 void OXUndoEnvironment::SetUndoMode(bool _bUndo)
 643 {
 644     m_pImpl->m_bIsUndo = _bUndo;
 645 }
 646
 647 bool OXUndoEnvironment::IsUndoMode() const
 648 {
 649     return m_pImpl->m_bIsUndo;
 650 }
 651
 652 } // rptui
 653
 654
 655 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */