forms/source/component/entrylisthelper.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
  20 #pragma once
  21
  22 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  23 #include <com/sun/star/util/XRefreshable.hpp>
  24 #include <com/sun/star/form/binding/XListEntryListener.hpp>
  25
  26 #include <cppuhelper/implbase3.hxx>
  27 #include <comphelper/interfacecontainer3.hxx>
  28
  29
  30 namespace frm
  31 {
  32
  33
  34     class OControlModel;
  35     class ControlModelLock;
  36
  37
  38     //= OEntryListHelper
  39
  40     typedef ::cppu::ImplHelper3 <   css::form::binding::XListEntrySink
  41                                 ,   css::form::binding::XListEntryListener
  42                                 ,   css::util::XRefreshable
  43                                 >   OEntryListHelper_BASE;
  44
  45     class OEntryListHelper : public OEntryListHelper_BASE
  46     {
  47     private:
  48         OControlModel&  m_rControlModel;
  49
  50         css::uno::Reference< css::form::binding::XListEntrySource >
  51                         m_xListSource;      /// our external list source
  52         std::vector< OUString >
  53                         m_aStringItems;     /// "overridden" StringItemList property value
  54         css::uno::Sequence< css::uno::Any >
  55                         m_aTypedItems;      /// "overridden" TypedItemList property value
  56         ::comphelper::OInterfaceContainerHelper3<css::util::XRefreshListener>
  57                         m_aRefreshListeners;
  58
  59
  60     protected:
  61         explicit OEntryListHelper( OControlModel& _rControlModel );
  62         OEntryListHelper( const OEntryListHelper& _rSource, OControlModel& _rControlModel );
  63         virtual ~OEntryListHelper( );
  64
  65         /// returns the current string item list
  66         const std::vector< OUString >&
  67                     getStringItemList() const { return m_aStringItems; }
  68
  69         /// returns the current typed item list
  70         const css::uno::Sequence< css::uno::Any >&
  71                     getTypedItemList() const { return m_aTypedItems; }
  72
  73         /// determines whether we actually have an external list source
  74         bool hasExternalListSource( ) const { return m_xListSource.is(); }
  75
  76         /** handling the XEventListener::disposing call for the case where
  77             our list source is being disposed
  78             @return
  79                 <TRUE/> if and only if the disposed object was our list source, and so the
  80                 event was handled
  81         */
  82         bool        handleDisposing( const css::lang::EventObject& _rEvent );
  83
  84         /** to be called by derived classes' instances when they're being disposed
  85         */
  86         void        disposing( );
  87
  88         // prevent method hiding
  89         virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override = 0;
  90
  91         /** helper for implementing convertFastPropertyValue( StringItemList )
  92
  93             <p>The signature of this method and the return type have the same semantics
  94             as convertFastPropertyValue.</p>
  95         */
  96         bool    convertNewListSourceProperty(
  97                         css::uno::Any& _rConvertedValue,
  98                         css::uno::Any& _rOldValue,
  99                         const css::uno::Any& _rValue
 100                     );
 101
 102         /** helper for implementing setFastPropertyValueNoBroadcast
 103
 104             <p>Will internally call stringItemListChanged after the new item list
 105             has been set.</p>
 106
 107             @precond
 108                 not to be called when we have an external list source
 109             @see hasExternalListSource
 110         */
 111         void        setNewStringItemList( const css::uno::Any& _rValue, ControlModelLock& _rInstanceLock );
 112
 113         /** helper for implementing setFastPropertyValueNoBroadcast
 114
 115             <p>Will internally call stringItemListChanged after the new item list
 116             has been set.</p>
 117
 118             @precond
 119                 not to be called when we have an external list source
 120             @see hasExternalListSource
 121         */
 122         void        setNewTypedItemList( const css::uno::Any& _rValue, ControlModelLock& _rInstanceLock );
 123
 124         /** announces that the list of entries has changed.
 125
 126             <p>Derived classes have to override this. Most probably, they'll set the new
 127             as model property.</p>
 128
 129             @pure
 130             @see getStringItemList
 131         */
 132         virtual void    stringItemListChanged( ControlModelLock& _rInstanceLock ) = 0;
 133
 134         /** called when XRefreshable::refresh has been called, and we do *not* have an external
 135             list source
 136         */
 137         virtual void    refreshInternalEntryList() = 0;
 138
 139     private:
 140         // XListEntrySink
 141         virtual void SAL_CALL setListEntrySource( const css::uno::Reference< css::form::binding::XListEntrySource >& _rxSource ) override;
 142         virtual css::uno::Reference< css::form::binding::XListEntrySource > SAL_CALL getListEntrySource(  ) override;
 143
 144         // XListEntryListener
 145         virtual void SAL_CALL entryChanged( const css::form::binding::ListEntryEvent& _rSource ) override;
 146         virtual void SAL_CALL entryRangeInserted( const css::form::binding::ListEntryEvent& _rSource ) override;
 147         virtual void SAL_CALL entryRangeRemoved( const css::form::binding::ListEntryEvent& _rSource ) override;
 148         virtual void SAL_CALL allEntriesChanged( const css::lang::EventObject& _rSource ) override;
 149
 150         // XRefreshable
 151         virtual void SAL_CALL refresh() override;
 152         virtual void SAL_CALL addRefreshListener(const css::uno::Reference< css::util::XRefreshListener>& _rxListener) override;
 153         virtual void SAL_CALL removeRefreshListener(const css::uno::Reference< css::util::XRefreshListener>& _rxListener) override;
 154
 155     private:
 156         /** disconnects from the active external list source, if present
 157             @see connectExternalListSource
 158         */
 159         void        disconnectExternalListSource( );
 160
 161         /** connects to a new external list source
 162             @param _rxSource
 163                 the new list source. Must not be <NULL/>
 164             @see disconnectExternalListSource
 165         */
 166         void        connectExternalListSource(
 167                         const css::uno::Reference< css::form::binding::XListEntrySource >& _rxSource,
 168                         ControlModelLock& _rInstanceLock
 169                     );
 170
 171         /** obtains list entries and possibly data values from list source
 172
 173             @precond
 174                 m_xListSource has to hold an external list source
 175         */
 176         void        obtainListSourceEntries( ControlModelLock& _rInstanceLock );
 177
 178         /** refreshes our list entries
 179
 180             In case we have an external list source, it's used to obtain the new entries, and then
 181             stringItemListChanged is called to give the derived class the possibility to
 182             react on this.
 183
 184             In case we do not have an external list source, refreshInternalEntryList is called.
 185         */
 186         void        impl_lock_refreshList( ControlModelLock& _rInstanceLock );
 187
 188     private:
 189         OEntryListHelper( const OEntryListHelper& ) = delete;
 190         OEntryListHelper& operator=( const OEntryListHelper& ) = delete;
 191     };
 192
 193
 194 }   // namespace frm
 195
 196 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */