LCOV - code coverage report
Current view: top level - reportdesign/source/ui/report - ReportControllerObserver.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 14 184 7.6 %
Date: 2014-11-03 Functions: 6 27 22.2 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <sal/config.h>
      21             : 
      22             : #include <map>
      23             : 
      24             : #include <ReportControllerObserver.hxx>
      25             : #include <ReportController.hxx>
      26             : #include <boost/noncopyable.hpp>
      27             : #include <svl/smplhint.hxx>
      28             : #include <osl/mutex.hxx>
      29             : #include <vcl/svapp.hxx>
      30             : #include <vcl/settings.hxx>
      31             : 
      32             : #include <com/sun/star/report/XFormattedField.hpp>
      33             : #include <com/sun/star/awt/FontSlant.hpp>
      34             : #include <FormattedFieldBeautifier.hxx>
      35             : 
      36             : #include <svx/unopage.hxx>
      37             : 
      38             : // DBG_*
      39             : #include <tools/debug.hxx>
      40             : // DBG_UNHANDLED_EXCEPTION
      41             : #include <tools/diagnose_ex.h>
      42             : 
      43             : namespace rptui
      44             : {
      45             : 
      46             :     using namespace ::com::sun::star;
      47             : 
      48             : typedef std::map<OUString, bool> AllProperties;
      49             : typedef std::map<uno::Reference< beans::XPropertySet >, AllProperties> PropertySetInfoCache;
      50             : 
      51             : class OXReportControllerObserverImpl: private boost::noncopyable
      52             : {
      53             : public:
      54             :     const OReportController&                            m_rReportController;
      55             :     ::std::vector< uno::Reference< container::XChild> > m_aSections;
      56             :     ::osl::Mutex                                        m_aMutex;
      57             :     oslInterlockedCount                                 m_nLocks;
      58             :     bool                                                m_bReadOnly;
      59             : 
      60             :     OXReportControllerObserverImpl(const OReportController& _rController);
      61             :     ~OXReportControllerObserverImpl();
      62             : };
      63             : 
      64             : 
      65             : 
      66           2 :     OXReportControllerObserverImpl::OXReportControllerObserverImpl(const OReportController& _rController)
      67             :             :m_rReportController(_rController)
      68             :             ,m_nLocks(0)
      69           2 :             ,m_bReadOnly(false)
      70             :     {
      71           2 :     }
      72             : 
      73           0 :     OXReportControllerObserverImpl::~OXReportControllerObserverImpl()
      74             :     {
      75           0 :     }
      76             : 
      77             : 
      78             : 
      79             : 
      80             : 
      81             : 
      82           2 :     OXReportControllerObserver::OXReportControllerObserver(const OReportController& _rController)
      83           2 :             :m_pImpl(new OXReportControllerObserverImpl(_rController) )
      84             :             ,m_aFormattedFieldBeautifier(_rController)
      85           4 :             ,m_aFixedTextColor(_rController)
      86             :     {
      87             : 
      88           2 :         Application::AddEventListener(LINK( this, OXReportControllerObserver, SettingsChanged ) );
      89           2 :     }
      90             : 
      91           0 :     OXReportControllerObserver::~OXReportControllerObserver()
      92             :     {
      93           0 :         Application::RemoveEventListener(LINK( this, OXReportControllerObserver, SettingsChanged ) );
      94           0 :     }
      95             : 
      96             : 
      97           8 :     IMPL_LINK(OXReportControllerObserver, SettingsChanged, VclWindowEvent*, _pEvt)
      98             :     {
      99           4 :         if ( _pEvt )
     100             :         {
     101           4 :             sal_Int32 nEvent = _pEvt->GetId();
     102             : 
     103           4 :             if (nEvent == VCLEVENT_APPLICATION_DATACHANGED )
     104             :             {
     105           0 :                 DataChangedEvent* pData = reinterpret_cast<DataChangedEvent*>(_pEvt->GetData());
     106           0 :                 if ( pData && ((( pData->GetType() == DATACHANGED_SETTINGS  )   ||
     107           0 :                                 ( pData->GetType() == DATACHANGED_DISPLAY   ))  &&
     108           0 :                                ( pData->GetFlags() & SETTINGS_STYLE     )))
     109             :                 {
     110           0 :                     OEnvLock aLock(*this);
     111             : 
     112             :                     // send all Section Objects a 'tingle'
     113             :                     // maybe they need a change in format, color, etc
     114           0 :                     ::std::vector< uno::Reference< container::XChild > >::const_iterator aIter = m_pImpl->m_aSections.begin();
     115           0 :                     ::std::vector< uno::Reference< container::XChild > >::const_iterator aEnd = m_pImpl->m_aSections.end();
     116           0 :                     for (;aIter != aEnd; ++aIter)
     117             :                     {
     118           0 :                         const uno::Reference<container::XChild> xChild (*aIter);
     119           0 :                         if (xChild.is())
     120             :                         {
     121           0 :                             uno::Reference<report::XSection> xSection(xChild, uno::UNO_QUERY);
     122           0 :                             if (xSection.is())
     123             :                             {
     124           0 :                                 const sal_Int32 nCount = xSection->getCount();
     125           0 :                                 for (sal_Int32 i = 0; i < nCount; ++i)
     126             :                                 {
     127           0 :                                     const uno::Any aObj = xSection->getByIndex(i);
     128           0 :                                     uno::Reference < report::XReportComponent > xReportComponent(aObj, uno::UNO_QUERY);
     129           0 :                                     if (xReportComponent.is())
     130             :                                     {
     131           0 :                                         m_aFormattedFieldBeautifier.handle(xReportComponent);
     132           0 :                                         m_aFixedTextColor.handle(xReportComponent);
     133             :                                     }
     134           0 :                                 }
     135           0 :                             }
     136             :                         }
     137           0 :                     }
     138             :                 }
     139             :             }
     140             :         }
     141             : 
     142           4 :         return 0L;
     143             :     }
     144             : 
     145             :     // XEventListener
     146           0 :     void SAL_CALL OXReportControllerObserver::disposing(const lang::EventObject& e) throw( uno::RuntimeException, std::exception )
     147             :     {
     148             :         (void) e;
     149             :         // check if it's an object we have cached information about
     150           0 :         uno::Reference< beans::XPropertySet > xSourceSet(e.Source, uno::UNO_QUERY);
     151           0 :         if ( xSourceSet.is() )
     152             :         {
     153           0 :             uno::Reference< report::XSection> xSection(xSourceSet,uno::UNO_QUERY);
     154           0 :             if ( xSection.is() )
     155           0 :                 RemoveSection(xSection);
     156             :             else
     157           0 :                 RemoveElement(xSourceSet);
     158           0 :         }
     159           0 :     }
     160             : 
     161           0 :     void OXReportControllerObserver::Clear()
     162             :     {
     163           0 :         OEnvLock aLock(*this);
     164           0 :         m_pImpl->m_aSections.clear();
     165           0 :     }
     166             : 
     167             :     // XPropertyChangeListener
     168           0 :     void SAL_CALL OXReportControllerObserver::propertyChange(const beans::PropertyChangeEvent& _rEvent) throw(uno::RuntimeException, std::exception)
     169             :     {
     170             :         (void) _rEvent;
     171           0 :         ::osl::ClearableMutexGuard aGuard( m_pImpl->m_aMutex );
     172             : 
     173           0 :         if ( IsLocked() )
     174           0 :             return;
     175             : 
     176           0 :         m_aFormattedFieldBeautifier.notifyPropertyChange(_rEvent);
     177           0 :         m_aFixedTextColor.notifyPropertyChange(_rEvent);
     178             :     }
     179             : 
     180             : 
     181           0 : void OXReportControllerObserver::Lock()
     182             : {
     183             :     OSL_ENSURE(m_refCount,"Illegal call to dead object!");
     184           0 :     osl_atomic_increment( &m_pImpl->m_nLocks );
     185           0 : }
     186             : 
     187           0 : void OXReportControllerObserver::UnLock()
     188             : {
     189             :     OSL_ENSURE(m_refCount,"Illegal call to dead object!");
     190             : 
     191           0 :     osl_atomic_decrement( &m_pImpl->m_nLocks );
     192           0 : }
     193             : 
     194           0 : bool OXReportControllerObserver::IsLocked() const
     195             : {
     196           0 :     return m_pImpl->m_nLocks != 0;
     197             : }
     198             : 
     199             : 
     200           0 : void OXReportControllerObserver::AddSection(const uno::Reference< report::XSection > & _xSection)
     201             : {
     202           0 :     OEnvLock aLock(*this);
     203             :     try
     204             :     {
     205           0 :         uno::Reference<container::XChild> xChild = _xSection.get();
     206           0 :         m_pImpl->m_aSections.push_back(xChild);
     207           0 :         uno::Reference< uno::XInterface >  xInt(_xSection);
     208           0 :         AddElement(xInt);
     209             :     }
     210           0 :     catch(const uno::Exception&)
     211             :     {
     212             :         DBG_UNHANDLED_EXCEPTION();
     213           0 :     }
     214           0 : }
     215             : 
     216             : 
     217           0 : void OXReportControllerObserver::RemoveSection(const uno::Reference< report::XSection > & _xSection)
     218             : {
     219           0 :     OEnvLock aLock(*this);
     220             :     try
     221             :     {
     222           0 :         uno::Reference<container::XChild> xChild(_xSection.get());
     223           0 :         m_pImpl->m_aSections.erase(::std::remove(m_pImpl->m_aSections.begin(),m_pImpl->m_aSections.end(),
     224           0 :             xChild), m_pImpl->m_aSections.end());
     225           0 :         uno::Reference< uno::XInterface >  xInt(_xSection);
     226           0 :         RemoveElement(xInt);
     227             :     }
     228           0 :     catch(uno::Exception&)
     229             :     {
     230             :         DBG_UNHANDLED_EXCEPTION();
     231           0 :     }
     232           0 : }
     233             : 
     234             : 
     235           0 : void OXReportControllerObserver::TogglePropertyListening(const uno::Reference< uno::XInterface > & Element)
     236             : {
     237             :     // listen at Container
     238           0 :     uno::Reference< container::XIndexAccess >  xContainer(Element, uno::UNO_QUERY);
     239           0 :     if (xContainer.is())
     240             :     {
     241           0 :         uno::Reference< uno::XInterface > xInterface;
     242           0 :         sal_Int32 nCount = xContainer->getCount();
     243           0 :         for(sal_Int32 i = 0;i != nCount;++i)
     244             :         {
     245           0 :             xInterface.set(xContainer->getByIndex( i ),uno::UNO_QUERY);
     246           0 :             TogglePropertyListening(xInterface);
     247           0 :         }
     248             :     }
     249             : 
     250           0 :     uno::Reference< beans::XPropertySet >  xSet(Element, uno::UNO_QUERY);
     251           0 :     if (xSet.is())
     252             :     {
     253           0 :         if (!m_pImpl->m_bReadOnly)
     254           0 :             xSet->addPropertyChangeListener( OUString(), this );
     255             :         else
     256           0 :             xSet->removePropertyChangeListener( OUString(), this );
     257           0 :     }
     258           0 : }
     259             : 
     260             : 
     261             : 
     262           0 : void OXReportControllerObserver::switchListening( const uno::Reference< container::XIndexAccess >& _rxContainer, bool _bStartListening )
     263             : {
     264             :     OSL_PRECOND( _rxContainer.is(), "OXReportControllerObserver::switchListening: invalid container!" );
     265           0 :     if ( !_rxContainer.is() )
     266           0 :         return;
     267             : 
     268             :     try
     269             :     {
     270             :         // also handle all children of this element
     271           0 :         uno::Reference< uno::XInterface > xInterface;
     272           0 :         sal_Int32 nCount = _rxContainer->getCount();
     273           0 :         for(sal_Int32 i = 0;i != nCount;++i)
     274             :         {
     275           0 :             xInterface.set(_rxContainer->getByIndex( i ),uno::UNO_QUERY);
     276           0 :             if ( _bStartListening )
     277           0 :                 AddElement( xInterface );
     278             :             else
     279           0 :                 RemoveElement( xInterface );
     280             :         }
     281             : 
     282             :         // be notified of any changes in the container elements
     283           0 :         uno::Reference< container::XContainer > xSimpleContainer( _rxContainer, uno::UNO_QUERY );
     284           0 :         if ( xSimpleContainer.is() )
     285             :         {
     286           0 :             if ( _bStartListening )
     287           0 :                 xSimpleContainer->addContainerListener( this );
     288             :             else
     289           0 :                 xSimpleContainer->removeContainerListener( this );
     290           0 :         }
     291             :     }
     292           0 :     catch( const uno::Exception& )
     293             :     {
     294             :         DBG_UNHANDLED_EXCEPTION();
     295             :     }
     296             : }
     297             : 
     298             : 
     299           0 : void OXReportControllerObserver::switchListening( const uno::Reference< uno::XInterface >& _rxObject, bool _bStartListening )
     300             : {
     301             :     OSL_PRECOND( _rxObject.is(), "OXReportControllerObserver::switchListening: how should I listen at a NULL object?" );
     302             : 
     303             :     try
     304             :     {
     305           0 :         if ( !m_pImpl->m_bReadOnly )
     306             :         {
     307           0 :             uno::Reference< beans::XPropertySet > xProps( _rxObject, uno::UNO_QUERY );
     308           0 :             if ( xProps.is() )
     309             :             {
     310           0 :                 if ( _bStartListening )
     311           0 :                     xProps->addPropertyChangeListener( OUString(), this );
     312             :                 else
     313           0 :                     xProps->removePropertyChangeListener( OUString(), this );
     314           0 :             }
     315             :         }
     316             : 
     317           0 :         uno::Reference< util::XModifyBroadcaster > xBroadcaster( _rxObject, uno::UNO_QUERY );
     318           0 :         if ( xBroadcaster.is() )
     319             :         {
     320           0 :             if ( _bStartListening )
     321           0 :                 xBroadcaster->addModifyListener( this );
     322             :             else
     323           0 :                 xBroadcaster->removeModifyListener( this );
     324           0 :         }
     325             :     }
     326           0 :     catch( const uno::Exception& )
     327             :     {
     328             :         DBG_UNHANDLED_EXCEPTION();
     329             :     }
     330           0 : }
     331             : 
     332             : 
     333           0 : void SAL_CALL OXReportControllerObserver::modified( const lang::EventObject& /*aEvent*/ ) throw (uno::RuntimeException, std::exception)
     334             : {
     335           0 : }
     336             : 
     337             : 
     338           0 : void OXReportControllerObserver::AddElement(const uno::Reference< uno::XInterface >& _rxElement )
     339             : {
     340           0 :     m_aFormattedFieldBeautifier.notifyElementInserted(_rxElement);
     341           0 :     m_aFixedTextColor.notifyElementInserted(_rxElement);
     342             : 
     343             :     // if it's a container, start listening at all elements
     344           0 :     uno::Reference< container::XIndexAccess > xContainer( _rxElement, uno::UNO_QUERY );
     345           0 :     if ( xContainer.is() )
     346           0 :         switchListening( xContainer, true );
     347             : 
     348           0 :     switchListening( _rxElement, true );
     349           0 : }
     350             : 
     351             : 
     352           0 : void OXReportControllerObserver::RemoveElement(const uno::Reference< uno::XInterface >& _rxElement)
     353             : {
     354           0 :     switchListening( _rxElement, false );
     355             : 
     356           0 :     uno::Reference< container::XIndexAccess > xContainer( _rxElement, uno::UNO_QUERY );
     357           0 :     if ( xContainer.is() )
     358           0 :         switchListening( xContainer, false );
     359           0 : }
     360             : 
     361             : 
     362           0 : ::std::vector< uno::Reference< container::XChild> >::const_iterator OXReportControllerObserver::getSection(const uno::Reference<container::XChild>& _xContainer) const
     363             : {
     364           0 :     ::std::vector< uno::Reference< container::XChild> >::const_iterator aFind = m_pImpl->m_aSections.end();
     365           0 :     if ( _xContainer.is() )
     366             :     {
     367           0 :         aFind = ::std::find(m_pImpl->m_aSections.begin(),m_pImpl->m_aSections.end(),_xContainer);
     368             : 
     369           0 :         if ( aFind == m_pImpl->m_aSections.end() )
     370             :         {
     371           0 :             uno::Reference<container::XChild> xParent(_xContainer->getParent(),uno::UNO_QUERY);
     372           0 :             aFind = getSection(xParent);
     373             :         }
     374             :     }
     375           0 :     return aFind;
     376             : }
     377             : // XContainerListener
     378             : 
     379           0 : void SAL_CALL OXReportControllerObserver::elementInserted(const container::ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
     380             : {
     381           0 :     SolarMutexGuard aSolarGuard;
     382           0 :     ::osl::MutexGuard aGuard( m_pImpl->m_aMutex );
     383             : 
     384             :     // neues Object zum lauschen
     385           0 :     uno::Reference< uno::XInterface >  xIface( evt.Element, uno::UNO_QUERY );
     386           0 :     if ( xIface.is() )
     387             :     {
     388           0 :         AddElement(xIface);
     389           0 :     }
     390           0 : }
     391             : 
     392             : 
     393           0 : void SAL_CALL OXReportControllerObserver::elementReplaced(const container::ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
     394             : {
     395           0 :     SolarMutexGuard aSolarGuard;
     396           0 :     ::osl::MutexGuard aGuard( m_pImpl->m_aMutex );
     397             : 
     398           0 :     uno::Reference< uno::XInterface >  xIface(evt.ReplacedElement,uno::UNO_QUERY);
     399             :     OSL_ENSURE(xIface.is(), "OXReportControllerObserver::elementReplaced: invalid container notification!");
     400           0 :     RemoveElement(xIface);
     401             : 
     402           0 :     xIface.set(evt.Element,uno::UNO_QUERY);
     403           0 :     AddElement(xIface);
     404           0 : }
     405             : 
     406             : 
     407           0 : void SAL_CALL OXReportControllerObserver::elementRemoved(const container::ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
     408             : {
     409           0 :     SolarMutexGuard aSolarGuard;
     410           0 :     ::osl::MutexGuard aGuard( m_pImpl->m_aMutex );
     411             : 
     412           0 :     uno::Reference< uno::XInterface >  xIface( evt.Element, uno::UNO_QUERY );
     413           0 :     if ( xIface.is() )
     414             :     {
     415           0 :         RemoveElement(xIface);
     416           0 :     }
     417           0 : }
     418             : 
     419             : 
     420           6 : } // namespace rptui
     421             : 
     422             : 
     423             : 
     424             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10