forms/source/component/entrylisthelper.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 "entrylisthelper.hxx"
  21 #include <FormComponent.hxx>
  22
  23 #include <osl/diagnose.h>
  24 #include <comphelper/sequence.hxx>
  25 #include <comphelper/property.hxx>
  26 #include <com/sun/star/form/binding/XListEntryTypedSource.hpp>
  27 #include <algorithm>
  28
  29
  30 namespace frm
  31 {
  32
  33
  34     using namespace ::com::sun::star::uno;
  35     using namespace ::com::sun::star::lang;
  36     using namespace ::com::sun::star::util;
  37     using namespace ::com::sun::star::form::binding;
  38
  39     OEntryListHelper::OEntryListHelper( OControlModel& _rControlModel )
  40         :m_rControlModel( _rControlModel )
  41         ,m_aRefreshListeners( _rControlModel.getInstanceMutex() )
  42     {
  43     }
  44
  45
  46     OEntryListHelper::OEntryListHelper( const OEntryListHelper& _rSource, OControlModel& _rControlModel )
  47         :m_rControlModel( _rControlModel )
  48         ,m_xListSource ( _rSource.m_xListSource  )
  49         ,m_aStringItems( _rSource.m_aStringItems )
  50         ,m_aRefreshListeners( _rControlModel.getInstanceMutex() )
  51     {
  52     }
  53
  54
  55     OEntryListHelper::~OEntryListHelper( )
  56     {
  57     }
  58
  59
  60     void SAL_CALL OEntryListHelper::setListEntrySource( const Reference< XListEntrySource >& _rxSource )
  61     {
  62         ControlModelLock aLock( m_rControlModel );
  63
  64         // disconnect from the current external list source
  65         disconnectExternalListSource();
  66
  67         // and connect to the new one
  68         if ( _rxSource.is() )
  69             connectExternalListSource( _rxSource, aLock );
  70     }
  71
  72
  73     Reference< XListEntrySource > SAL_CALL OEntryListHelper::getListEntrySource(  )
  74     {
  75         return m_xListSource;
  76     }
  77
  78
  79     void SAL_CALL OEntryListHelper::entryChanged( const ListEntryEvent& _rEvent )
  80     {
  81         ControlModelLock aLock( m_rControlModel );
  82
  83         OSL_ENSURE( _rEvent.Source == m_xListSource,
  84             "OEntryListHelper::entryChanged: where did this come from?" );
  85         OSL_ENSURE( ( _rEvent.Position >= 0 ) && ( _rEvent.Position < static_cast<sal_Int32>(m_aStringItems.size()) ),
  86             "OEntryListHelper::entryChanged: invalid index!" );
  87         OSL_ENSURE( _rEvent.Entries.getLength() == 1,
  88             "OEntryListHelper::entryChanged: invalid string list!" );
  89
  90         if  (   ( _rEvent.Position >= 0 )
  91             &&  ( _rEvent.Position < static_cast<sal_Int32>(m_aStringItems.size()) )
  92             &&  _rEvent.Entries.hasElements()
  93             )
  94         {
  95             m_aStringItems[ _rEvent.Position ] = _rEvent.Entries[ 0 ];
  96             if (m_aTypedItems.hasElements())
  97                 m_aTypedItems = Sequence<Any>();    // doesn't match anymore
  98             stringItemListChanged( aLock );
  99         }
 100     }
 101
 102
 103     void SAL_CALL OEntryListHelper::entryRangeInserted( const ListEntryEvent& _rEvent )
 104     {
 105         ControlModelLock aLock( m_rControlModel );
 106
 107         OSL_ENSURE( _rEvent.Source == m_xListSource,
 108             "OEntryListHelper::entryRangeInserted: where did this come from?" );
 109         OSL_ENSURE( ( _rEvent.Position > 0 ) && ( _rEvent.Position < static_cast<sal_Int32>(m_aStringItems.size()) ) && _rEvent.Entries.hasElements(),
 110             "OEntryListHelper::entryRangeRemoved: invalid count and/or position!" );
 111
 112         if  (   ( _rEvent.Position > 0 )
 113             &&  ( _rEvent.Position < static_cast<sal_Int32>(m_aStringItems.size()) )
 114             &&  _rEvent.Entries.hasElements()
 115             )
 116         {
 117             m_aStringItems.insert(m_aStringItems.begin() + _rEvent.Position, _rEvent.Entries.begin(), _rEvent.Entries.end());
 118             if (m_aTypedItems.hasElements())
 119                 m_aTypedItems = Sequence<Any>();    // doesn't match anymore
 120             stringItemListChanged( aLock );
 121         }
 122     }
 123
 124
 125     void SAL_CALL OEntryListHelper::entryRangeRemoved( const ListEntryEvent& _rEvent )
 126     {
 127         ControlModelLock aLock( m_rControlModel );
 128
 129         OSL_ENSURE( _rEvent.Source == m_xListSource,
 130             "OEntryListHelper::entryRangeRemoved: where did this come from?" );
 131         OSL_ENSURE( ( _rEvent.Position > 0 ) && ( _rEvent.Count > 0 ) && ( _rEvent.Position + _rEvent.Count <= static_cast<sal_Int32>(m_aStringItems.size()) ),
 132             "OEntryListHelper::entryRangeRemoved: invalid count and/or position!" );
 133
 134         if  (   !(( _rEvent.Position > 0 )
 135             &&  ( _rEvent.Count > 0 )
 136             &&  ( _rEvent.Position + _rEvent.Count <= static_cast<sal_Int32>(m_aStringItems.size()) ))
 137             )
 138             return;
 139
 140         m_aStringItems.erase(m_aStringItems.begin() + _rEvent.Position,
 141                              m_aStringItems.begin() + _rEvent.Position + _rEvent.Count );
 142         if (_rEvent.Position + _rEvent.Count <= m_aTypedItems.getLength())
 143         {
 144             Sequence<Any> aTmp( m_aTypedItems.getLength() - _rEvent.Count );
 145             sal_Int32 nStop = _rEvent.Position;
 146             sal_Int32 i = 0;
 147             for ( ; i < nStop; ++i)
 148             {
 149                 aTmp[i] = m_aTypedItems[i];
 150             }
 151             nStop = aTmp.getLength();
 152             for (sal_Int32 j = _rEvent.Position + _rEvent.Count; i < nStop; ++i, ++j)
 153             {
 154                 aTmp[i] = m_aTypedItems[j];
 155             }
 156             m_aTypedItems = aTmp;
 157         }
 158         else if (m_aTypedItems.hasElements())
 159         {
 160             m_aTypedItems = Sequence<Any>();    // doesn't match anymore
 161         }
 162         stringItemListChanged( aLock );
 163     }
 164
 165
 166     void SAL_CALL OEntryListHelper::allEntriesChanged( const EventObject& _rEvent )
 167     {
 168         ControlModelLock aLock( m_rControlModel );
 169
 170         OSL_ENSURE( _rEvent.Source == m_xListSource,
 171             "OEntryListHelper::allEntriesChanged: where did this come from?" );
 172
 173         if ( _rEvent.Source == m_xListSource )
 174         {
 175             impl_lock_refreshList( aLock );
 176         }
 177     }
 178
 179     // XRefreshable
 180
 181     void SAL_CALL OEntryListHelper::addRefreshListener(const Reference<XRefreshListener>& _rxListener)
 182     {
 183         if ( _rxListener.is() )
 184             m_aRefreshListeners.addInterface( _rxListener );
 185     }
 186
 187
 188     void SAL_CALL OEntryListHelper::removeRefreshListener(const Reference<XRefreshListener>& _rxListener)
 189     {
 190         if ( _rxListener.is() )
 191             m_aRefreshListeners.removeInterface( _rxListener );
 192     }
 193
 194
 195     void SAL_CALL OEntryListHelper::refresh()
 196     {
 197         {
 198             ControlModelLock aLock( m_rControlModel );
 199             impl_lock_refreshList( aLock );
 200         }
 201
 202         EventObject aEvt( static_cast< XRefreshable* >( this ) );
 203         m_aRefreshListeners.notifyEach( &XRefreshListener::refreshed, aEvt );
 204     }
 205
 206
 207     void OEntryListHelper::impl_lock_refreshList( ControlModelLock& _rInstanceLock )
 208     {
 209         if ( hasExternalListSource() )
 210             obtainListSourceEntries( _rInstanceLock );
 211         else
 212             refreshInternalEntryList();
 213     }
 214
 215
 216     bool OEntryListHelper::handleDisposing( const EventObject& _rEvent )
 217     {
 218         if ( m_xListSource .is() && ( _rEvent.Source == m_xListSource ) )
 219         {
 220             disconnectExternalListSource( );
 221             return true;
 222         }
 223         return false;
 224     }
 225
 226
 227     void OEntryListHelper::disposing( )
 228     {
 229         EventObject aEvt( static_cast< XRefreshable* >( this ) );
 230         m_aRefreshListeners.disposeAndClear(aEvt);
 231
 232         if ( hasExternalListSource( ) )
 233             disconnectExternalListSource( );
 234     }
 235
 236
 237     void OEntryListHelper::disconnectExternalListSource( )
 238     {
 239         if ( m_xListSource.is() )
 240             m_xListSource->removeListEntryListener( this );
 241
 242         m_xListSource.clear();
 243     }
 244
 245
 246     void OEntryListHelper::connectExternalListSource( const Reference< XListEntrySource >& _rxSource, ControlModelLock& _rInstanceLock )
 247     {
 248         OSL_ENSURE( !hasExternalListSource(), "OEntryListHelper::connectExternalListSource: only to be called if no external source is active!" );
 249         OSL_ENSURE( _rxSource.is(), "OEntryListHelper::connectExternalListSource: invalid list source!" );
 250
 251         // remember it
 252         m_xListSource = _rxSource;
 253
 254         // initially fill our item list
 255         if ( m_xListSource.is() )
 256         {
 257             // be notified when the list changes ...
 258             m_xListSource->addListEntryListener( this );
 259
 260             obtainListSourceEntries( _rInstanceLock );
 261         }
 262     }
 263
 264
 265     void OEntryListHelper::obtainListSourceEntries( ControlModelLock& _rInstanceLock )
 266     {
 267         Reference< XListEntryTypedSource > xTyped;
 268         xTyped.set( m_xListSource, UNO_QUERY);
 269         if (xTyped.is())
 270         {
 271             comphelper::sequenceToContainer( m_aStringItems, xTyped->getAllListEntriesTyped( m_aTypedItems));
 272         }
 273         else
 274         {
 275             comphelper::sequenceToContainer( m_aStringItems, m_xListSource->getAllListEntries());
 276             if (m_aTypedItems.hasElements())
 277                 m_aTypedItems = Sequence<Any>();
 278         }
 279         stringItemListChanged( _rInstanceLock );
 280     }
 281
 282
 283     bool OEntryListHelper::convertNewListSourceProperty( Any& _rConvertedValue,
 284         Any& _rOldValue, const Any& _rValue )
 285     {
 286         if ( hasExternalListSource() )
 287             throw IllegalArgumentException( );
 288             // TODO: error message
 289
 290         return ::comphelper::tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, comphelper::containerToSequence(m_aStringItems) );
 291     }
 292
 293
 294     void OEntryListHelper::setNewStringItemList( const css::uno::Any& _rValue, ControlModelLock& _rInstanceLock )
 295     {
 296         OSL_PRECOND( !hasExternalListSource(), "OEntryListHelper::setNewStringItemList: this should never have survived convertNewListSourceProperty!" );
 297         css::uno::Sequence<OUString> aTmp;
 298         OSL_VERIFY( _rValue >>= aTmp );
 299         comphelper::sequenceToContainer(m_aStringItems, aTmp);
 300         if (m_aTypedItems.hasElements())
 301             m_aTypedItems = Sequence<Any>();    // doesn't match anymore
 302         stringItemListChanged( _rInstanceLock );
 303     }
 304
 305
 306     void OEntryListHelper::setNewTypedItemList( const css::uno::Any& _rValue, ControlModelLock& _rInstanceLock )
 307     {
 308         OSL_PRECOND( !hasExternalListSource(), "OEntryListHelper::setNewTypedItemList: this should never have survived convertNewListSourceProperty!" );
 309         if (!(_rValue >>= m_aTypedItems ))
 310         {
 311             OSL_VERIFY(false);
 312             if (m_aTypedItems.hasElements())
 313                 m_aTypedItems = Sequence<Any>();    // doesn't match anymore
 314         }
 315         // Sets both properties, assuming that TypedItemList belongs to StringItemList.
 316         stringItemListChanged( _rInstanceLock );
 317     }
 318
 319
 320 }   // namespace frm
 321
 322
 323 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */