chart2/source/inc/ModifyListenerHelper.hxx

   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 #pragma once
  20
  21 #include <com/sun/star/util/XModifyListener.hpp>
  22 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  23 #include <cppuhelper/compbase.hxx>
  24
  25 #include "MutexContainer.hxx"
  26
  27 #include <vector>
  28 #include <algorithm>
  29 #include <utility>
  30
  31 namespace com::sun::star::uno { class XWeak; }
  32 namespace com::sun::star::uno { template <class interface_type> class WeakReference; }
  33
  34 namespace chart::ModifyListenerHelper
  35 {
  36
  37 css::uno::Reference< css::util::XModifyListener > createModifyEventForwarder();
  38
  39 /** This helper class serves as forwarder of modify events.  It can be used
  40     whenever an object has to send modify events after it gets a modify event of
  41     one of its children.
  42
  43     <p>The listeners are held as WeakReferences if they support XWeak.  Thus the
  44     life time of the listeners is independent of the broadcaster's lifetime in
  45     this case.</p>
  46  */
  47 class ModifyEventForwarder :
  48         public MutexContainer,
  49         public ::cppu::WeakComponentImplHelper<
  50             css::util::XModifyBroadcaster,
  51             css::util::XModifyListener >
  52 {
  53 public:
  54     ModifyEventForwarder();
  55
  56     void AddListener(
  57         const css::uno::Reference< css::util::XModifyListener >& aListener );
  58     void RemoveListener(
  59         const css::uno::Reference< css::util::XModifyListener >& aListener );
  60
  61 protected:
  62     // ____ XModifyBroadcaster ____
  63     virtual void SAL_CALL addModifyListener(
  64         const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
  65     virtual void SAL_CALL removeModifyListener(
  66         const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
  67
  68     // ____ XModifyListener ____
  69     virtual void SAL_CALL modified(
  70         const css::lang::EventObject& aEvent ) override;
  71
  72     // ____ XEventListener (base of XModifyListener) ____
  73     virtual void SAL_CALL disposing(
  74         const css::lang::EventObject& Source ) override;
  75
  76     // ____ WeakComponentImplHelperBase ____
  77     virtual void SAL_CALL disposing() override;
  78
  79 private:
  80     /// call disposing() at all listeners and remove all listeners
  81     void DisposeAndClear( const css::uno::Reference<
  82                               css::uno::XWeak > & xSource );
  83
  84 //     ::osl::Mutex & m_rMutex;
  85     ::cppu::OBroadcastHelper  m_aModifyListeners;
  86
  87     typedef std::vector<
  88             std::pair<
  89             css::uno::WeakReference< css::util::XModifyListener >,
  90             css::uno::Reference< css::util::XModifyListener > > >
  91         tListenerMap;
  92
  93     tListenerMap m_aListenerMap;
  94 };
  95
  96 namespace impl
  97 {
  98
  99 template< class InterfaceRef >
 100 struct addListenerFunctor
 101 {
 102     explicit addListenerFunctor( const css::uno::Reference< css::util::XModifyListener > & xListener ) :
 103             m_xListener( xListener )
 104     {}
 105
 106     void operator() ( const InterfaceRef & xObject )
 107     {
 108         css::uno::Reference< css::util::XModifyBroadcaster >
 109               xBroadcaster( xObject, css::uno::UNO_QUERY );
 110         if( xBroadcaster.is() && m_xListener.is())
 111             xBroadcaster->addModifyListener( m_xListener );
 112     }
 113 private:
 114     css::uno::Reference< css::util::XModifyListener > m_xListener;
 115 };
 116
 117 template< class InterfaceRef >
 118 struct removeListenerFunctor
 119 {
 120     explicit removeListenerFunctor( const css::uno::Reference< css::util::XModifyListener > & xListener ) :
 121             m_xListener( xListener )
 122     {}
 123
 124     void operator() ( const InterfaceRef & xObject )
 125     {
 126         css::uno::Reference< css::util::XModifyBroadcaster >
 127               xBroadcaster( xObject, css::uno::UNO_QUERY );
 128         if( xBroadcaster.is() && m_xListener.is())
 129             xBroadcaster->removeModifyListener( m_xListener );
 130     }
 131 private:
 132     css::uno::Reference< css::util::XModifyListener > m_xListener;
 133 };
 134
 135 template< class Pair >
 136 struct addListenerToMappedElementFunctor
 137 {
 138     explicit addListenerToMappedElementFunctor( const css::uno::Reference< css::util::XModifyListener > & xListener ) :
 139             m_xListener( xListener )
 140     {}
 141
 142     void operator() ( const Pair & aPair )
 143     {
 144         css::uno::Reference< css::util::XModifyBroadcaster >
 145               xBroadcaster( aPair.second, css::uno::UNO_QUERY );
 146         if( xBroadcaster.is() && m_xListener.is())
 147             xBroadcaster->addModifyListener( m_xListener );
 148     }
 149 private:
 150     css::uno::Reference< css::util::XModifyListener > m_xListener;
 151 };
 152
 153 template< class Pair >
 154 struct removeListenerFromMappedElementFunctor
 155 {
 156     explicit removeListenerFromMappedElementFunctor( const css::uno::Reference< css::util::XModifyListener > & xListener ) :
 157             m_xListener( xListener )
 158     {}
 159
 160     void operator() ( const Pair & aPair )
 161     {
 162         css::uno::Reference< css::util::XModifyBroadcaster >
 163               xBroadcaster( aPair.second, css::uno::UNO_QUERY );
 164         if( xBroadcaster.is() && m_xListener.is())
 165             xBroadcaster->removeModifyListener( m_xListener );
 166     }
 167 private:
 168     css::uno::Reference< css::util::XModifyListener > m_xListener;
 169 };
 170
 171 } //  namespace impl
 172
 173 template< class InterfaceRef >
 174 void addListener(
 175     const InterfaceRef & xObject,
 176     const css::uno::Reference< css::util::XModifyListener > & xListener )
 177 {
 178     if( xListener.is())
 179     {
 180         impl::addListenerFunctor< InterfaceRef > aFunctor( xListener );
 181         aFunctor( xObject );
 182     }
 183 }
 184
 185 template< class Container >
 186 void addListenerToAllElements(
 187     const Container & rContainer,
 188     const css::uno::Reference< css::util::XModifyListener > & xListener )
 189 {
 190     if( xListener.is())
 191         std::for_each( rContainer.begin(), rContainer.end(),
 192                          impl::addListenerFunctor< typename Container::value_type >( xListener ));
 193 }
 194
 195 template< class Container >
 196 void addListenerToAllMapElements(
 197     const Container & rContainer,
 198     const css::uno::Reference< css::util::XModifyListener > & xListener )
 199 {
 200     if( xListener.is())
 201         std::for_each( rContainer.begin(), rContainer.end(),
 202                          impl::addListenerToMappedElementFunctor< typename Container::value_type >( xListener ));
 203 }
 204
 205 template< typename T >
 206 void addListenerToAllSequenceElements(
 207     const css::uno::Sequence< T > & rSequence,
 208     const css::uno::Reference< css::util::XModifyListener > & xListener )
 209 {
 210     if( xListener.is())
 211         std::for_each( rSequence.begin(), rSequence.end(),
 212                          impl::addListenerFunctor< T >( xListener ));
 213 }
 214
 215 template< class InterfaceRef >
 216 void removeListener(
 217     const InterfaceRef & xObject,
 218     const css::uno::Reference< css::util::XModifyListener > & xListener )
 219 {
 220     if( xListener.is())
 221     {
 222         impl::removeListenerFunctor< InterfaceRef > aFunctor( xListener );
 223         aFunctor( xObject );
 224     }
 225 }
 226
 227 template< class Container >
 228 void removeListenerFromAllElements(
 229     const Container & rContainer,
 230     const css::uno::Reference< css::util::XModifyListener > & xListener )
 231 {
 232     if( xListener.is())
 233         std::for_each( rContainer.begin(), rContainer.end(),
 234                          impl::removeListenerFunctor< typename Container::value_type >( xListener ));
 235 }
 236
 237 template< class Container >
 238 void removeListenerFromAllMapElements(
 239     const Container & rContainer,
 240     const css::uno::Reference< css::util::XModifyListener > & xListener )
 241 {
 242     if( xListener.is())
 243         std::for_each( rContainer.begin(), rContainer.end(),
 244                          impl::removeListenerFromMappedElementFunctor< typename Container::value_type >( xListener ));
 245 }
 246
 247 template< typename T >
 248 void removeListenerFromAllSequenceElements(
 249     const css::uno::Sequence< T > & rSequence,
 250     const css::uno::Reference< css::util::XModifyListener > & xListener )
 251 {
 252     if( xListener.is())
 253         std::for_each( rSequence.begin(), rSequence.end(),
 254                          impl::removeListenerFunctor< T >( xListener ));
 255 }
 256
 257 } //  namespace chart::ModifyListenerHelper
 258
 259 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */