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