868 lines
32 KiB
C++
868 lines
32 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <comphelper/propagg.hxx>
|
|
#include <comphelper/property.hxx>
|
|
#include <comphelper/sequence.hxx>
|
|
#include <cppuhelper/queryinterface.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include <sal/log.hxx>
|
|
#include <com/sun/star/beans/PropertyAttribute.hpp>
|
|
#include <o3tl/sorted_vector.hxx>
|
|
#include <typeinfo>
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <unordered_set>
|
|
#include <memory>
|
|
|
|
|
|
namespace comphelper
|
|
{
|
|
|
|
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::lang;
|
|
using namespace ::com::sun::star::beans;
|
|
|
|
using namespace internal;
|
|
|
|
|
|
namespace
|
|
{
|
|
const Property* lcl_findPropertyByName( const std::vector< Property >& _rProps, const OUString& _rName )
|
|
{
|
|
Property aNameProp(_rName, 0, Type(), 0);
|
|
auto pResult = std::lower_bound(_rProps.begin(), _rProps.end(), aNameProp, PropertyCompareByName());
|
|
if ( pResult == _rProps.end() || pResult->Name != _rName )
|
|
return nullptr;
|
|
|
|
return &*pResult;
|
|
}
|
|
}
|
|
|
|
OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper(
|
|
const Sequence< Property >& _rProperties, const Sequence< Property >& _rAggProperties,
|
|
IPropertyInfoService* _pInfoService, sal_Int32 _nFirstAggregateId )
|
|
{
|
|
// if properties are present both at the delegatee and the aggregate, then the former are supposed to win
|
|
// merge and sort properties by name, delete duplicates (stable sort ensures delegator properties win)
|
|
m_aProperties.insert( m_aProperties.end(), _rProperties.begin(), _rProperties.end() );
|
|
m_aProperties.insert( m_aProperties.end(), _rAggProperties.begin(), _rAggProperties.end() );
|
|
std::stable_sort( m_aProperties.begin(), m_aProperties.end(), PropertyCompareByName() );
|
|
m_aProperties.erase( std::unique(m_aProperties.begin(), m_aProperties.end(),
|
|
[]( const css::beans::Property& x, const css::beans::Property& y ) -> bool { return x.Name == y.Name; } ),
|
|
m_aProperties.end() );
|
|
m_aProperties.shrink_to_fit();
|
|
|
|
// fill aDelegatorProps with names from _rProperties for a fast existence check
|
|
// different kinds of properties are processed differently
|
|
std::unordered_set< OUString > aDelegatorProps;
|
|
aDelegatorProps.reserve( _rProperties.getLength() );
|
|
for( auto &delegateProp: _rProperties )
|
|
{
|
|
const auto inserted = aDelegatorProps.insert( delegateProp.Name );
|
|
OSL_ENSURE( inserted.second,
|
|
"OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper: duplicate delegatee property!" );
|
|
}
|
|
|
|
std::unordered_set< sal_Int32 > existingHandles;
|
|
existingHandles.reserve( m_aProperties.size() );
|
|
sal_Int32 nAggregateHandle = _nFirstAggregateId;
|
|
for ( std::size_t nMPLoop = 0; nMPLoop < m_aProperties.size(); ++nMPLoop )
|
|
{
|
|
auto &prop = m_aProperties[ nMPLoop ];
|
|
if ( aDelegatorProps.find( prop.Name ) != aDelegatorProps.end() )
|
|
{
|
|
m_aPropertyAccessors.insert_or_assign(
|
|
prop.Handle, OPropertyAccessor( -1, nMPLoop, false ));
|
|
existingHandles.insert( prop.Handle );
|
|
}
|
|
else
|
|
{
|
|
// determine the handle for the property which we will expose to the outside world
|
|
sal_Int32 nHandle = -1;
|
|
// ask the info service first
|
|
if ( _pInfoService )
|
|
nHandle = _pInfoService->getPreferredPropertyId( prop.Name );
|
|
|
|
if ( ( -1 == nHandle ) || ( existingHandles.find( nHandle ) != existingHandles.end() ) )
|
|
{
|
|
// 1. no handle from the info service -> default
|
|
// 2. conflicts -> use another one (which we don't check anymore, assuming _nFirstAggregateId was large enough)
|
|
nHandle = nAggregateHandle++;
|
|
}
|
|
else
|
|
{
|
|
existingHandles.insert( nHandle );
|
|
}
|
|
|
|
// remember the accessor for this property
|
|
m_aPropertyAccessors.insert_or_assign(
|
|
nHandle, OPropertyAccessor( prop.Handle, nMPLoop, true ));
|
|
prop.Handle = nHandle;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
OPropertyArrayAggregationHelper::PropertyOrigin OPropertyArrayAggregationHelper::classifyProperty( const OUString& _rName )
|
|
{
|
|
PropertyOrigin eOrigin = PropertyOrigin::Unknown;
|
|
// look up the name
|
|
const Property* pPropertyDescriptor = lcl_findPropertyByName( m_aProperties, _rName );
|
|
if ( pPropertyDescriptor )
|
|
{
|
|
// look up the handle for this name
|
|
auto aPos = m_aPropertyAccessors.find( pPropertyDescriptor->Handle );
|
|
OSL_ENSURE( m_aPropertyAccessors.end() != aPos, "OPropertyArrayAggregationHelper::classifyProperty: should have this handle in my map!" );
|
|
if ( m_aPropertyAccessors.end() != aPos )
|
|
{
|
|
eOrigin = aPos->second.bAggregate ? PropertyOrigin::Aggregate : PropertyOrigin::Delegator;
|
|
}
|
|
}
|
|
return eOrigin;
|
|
}
|
|
|
|
|
|
Property OPropertyArrayAggregationHelper::getPropertyByName( const OUString& _rPropertyName )
|
|
{
|
|
const Property* pProperty = findPropertyByName( _rPropertyName );
|
|
|
|
if ( !pProperty )
|
|
throw UnknownPropertyException(_rPropertyName);
|
|
|
|
return *pProperty;
|
|
}
|
|
|
|
|
|
sal_Bool OPropertyArrayAggregationHelper::hasPropertyByName(const OUString& _rPropertyName)
|
|
{
|
|
return nullptr != findPropertyByName( _rPropertyName );
|
|
}
|
|
|
|
|
|
const Property* OPropertyArrayAggregationHelper::findPropertyByName(const OUString& _rName ) const
|
|
{
|
|
return lcl_findPropertyByName( m_aProperties, _rName );
|
|
}
|
|
|
|
|
|
sal_Int32 OPropertyArrayAggregationHelper::getHandleByName(const OUString& _rPropertyName)
|
|
{
|
|
const Property* pProperty = findPropertyByName( _rPropertyName );
|
|
return pProperty ? pProperty->Handle : -1;
|
|
}
|
|
|
|
|
|
sal_Bool OPropertyArrayAggregationHelper::fillPropertyMembersByHandle(
|
|
OUString* _pPropName, sal_Int16* _pAttributes, sal_Int32 _nHandle)
|
|
{
|
|
auto i = m_aPropertyAccessors.find(_nHandle);
|
|
bool bRet = i != m_aPropertyAccessors.end();
|
|
if (bRet)
|
|
{
|
|
const css::beans::Property& rProperty = m_aProperties[(*i).second.nPos];
|
|
if (_pPropName)
|
|
*_pPropName = rProperty.Name;
|
|
if (_pAttributes)
|
|
*_pAttributes = rProperty.Attributes;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
bool OPropertyArrayAggregationHelper::getPropertyByHandle( sal_Int32 _nHandle, Property& _rProperty ) const
|
|
{
|
|
auto pos = m_aPropertyAccessors.find(_nHandle);
|
|
if ( pos != m_aPropertyAccessors.end() )
|
|
{
|
|
_rProperty = m_aProperties[ pos->second.nPos ];
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool OPropertyArrayAggregationHelper::fillAggregatePropertyInfoByHandle(
|
|
OUString* _pPropName, sal_Int32* _pOriginalHandle, sal_Int32 _nHandle) const
|
|
{
|
|
auto i = m_aPropertyAccessors.find(_nHandle);
|
|
bool bRet = i != m_aPropertyAccessors.end() && (*i).second.bAggregate;
|
|
if (bRet)
|
|
{
|
|
if (_pOriginalHandle)
|
|
*_pOriginalHandle = (*i).second.nOriginalHandle;
|
|
if (_pPropName)
|
|
{
|
|
OSL_ENSURE((*i).second.nPos < m_aProperties.size(),"Invalid index for sequence!");
|
|
const css::beans::Property& rProperty = m_aProperties[(*i).second.nPos];
|
|
*_pPropName = rProperty.Name;
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
css::uno::Sequence< css::beans::Property> OPropertyArrayAggregationHelper::getProperties()
|
|
{
|
|
return comphelper::containerToSequence(m_aProperties);
|
|
}
|
|
|
|
|
|
sal_Int32 OPropertyArrayAggregationHelper::fillHandles(
|
|
sal_Int32* _pHandles, const css::uno::Sequence< OUString >& _rPropNames )
|
|
{
|
|
sal_Int32 nHitCount = 0;
|
|
|
|
Property aNameProp;
|
|
for (sal_Int32 i = 0; i < _rPropNames.getLength(); ++i)
|
|
{
|
|
aNameProp.Name = _rPropNames[i];
|
|
auto findIter = std::lower_bound(m_aProperties.begin(), m_aProperties.end(), aNameProp, PropertyCompareByName());
|
|
if (findIter != m_aProperties.end() && findIter->Name == _rPropNames[i])
|
|
{
|
|
_pHandles[i] = findIter->Handle;
|
|
nHitCount++;
|
|
}
|
|
}
|
|
return nHitCount;
|
|
}
|
|
|
|
namespace internal
|
|
{
|
|
class PropertyForwarder
|
|
{
|
|
private:
|
|
OPropertySetAggregationHelper& m_rAggregationHelper;
|
|
o3tl::sorted_vector< sal_Int32 > m_aProperties;
|
|
sal_Int32 m_nCurrentlyForwarding;
|
|
|
|
public:
|
|
explicit PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper );
|
|
|
|
/** declares that the forwarder should be responsible for the given property
|
|
|
|
@param _nHandle
|
|
the public handle (<em>not</em> the original handle!) of the property
|
|
*/
|
|
void takeResponsibilityFor( sal_Int32 _nHandle );
|
|
|
|
/** checks whether the forwarder is responsible for the given property
|
|
*/
|
|
bool isResponsibleFor( sal_Int32 _nHandle ) const;
|
|
|
|
/// actually forwards a property value to the aggregate
|
|
///
|
|
/// @throws Exception
|
|
void doForward( sal_Int32 _nHandle, const Any& _rValue );
|
|
|
|
sal_Int32 getCurrentlyForwardedProperty( ) const { return m_nCurrentlyForwarding; }
|
|
};
|
|
|
|
|
|
PropertyForwarder::PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper )
|
|
:m_rAggregationHelper( _rAggregationHelper )
|
|
,m_nCurrentlyForwarding( -1 )
|
|
{
|
|
}
|
|
|
|
|
|
void PropertyForwarder::takeResponsibilityFor( sal_Int32 _nHandle )
|
|
{
|
|
m_aProperties.insert( _nHandle );
|
|
}
|
|
|
|
|
|
bool PropertyForwarder::isResponsibleFor( sal_Int32 _nHandle ) const
|
|
{
|
|
return m_aProperties.find( _nHandle ) != m_aProperties.end();
|
|
}
|
|
|
|
|
|
void PropertyForwarder::doForward( sal_Int32 _nHandle, const Any& _rValue )
|
|
{
|
|
OSL_ENSURE( m_rAggregationHelper.m_xAggregateSet.is(), "PropertyForwarder::doForward: no property set!" );
|
|
if ( !m_rAggregationHelper.m_xAggregateSet.is() )
|
|
return;
|
|
|
|
m_rAggregationHelper.forwardingPropertyValue( _nHandle );
|
|
|
|
OSL_ENSURE( m_nCurrentlyForwarding == -1, "PropertyForwarder::doForward: reentrance?" );
|
|
m_nCurrentlyForwarding = _nHandle;
|
|
|
|
try
|
|
{
|
|
m_rAggregationHelper.m_xAggregateSet->setPropertyValue( m_rAggregationHelper.getPropertyName( _nHandle ), _rValue );
|
|
// TODO: cache the property name? (it's a O(log n) search)
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
m_rAggregationHelper.forwardedPropertyValue( _nHandle );
|
|
throw;
|
|
}
|
|
|
|
m_nCurrentlyForwarding = -1;
|
|
|
|
m_rAggregationHelper.forwardedPropertyValue( _nHandle );
|
|
}
|
|
}
|
|
|
|
OPropertySetAggregationHelper::OPropertySetAggregationHelper( ::cppu::OBroadcastHelper& rBHlp )
|
|
:OPropertyStateHelper( rBHlp )
|
|
,m_bListening( false )
|
|
{
|
|
m_pForwarder.reset( new PropertyForwarder( *this ) );
|
|
}
|
|
|
|
|
|
OPropertySetAggregationHelper::~OPropertySetAggregationHelper()
|
|
{
|
|
}
|
|
|
|
|
|
css::uno::Any SAL_CALL OPropertySetAggregationHelper::queryInterface(const css::uno::Type& _rType)
|
|
{
|
|
css::uno::Any aReturn = OPropertyStateHelper::queryInterface(_rType);
|
|
|
|
if ( !aReturn.hasValue() )
|
|
aReturn = cppu::queryInterface(_rType
|
|
,static_cast< css::beans::XPropertiesChangeListener*>(this)
|
|
,static_cast< css::beans::XVetoableChangeListener*>(this)
|
|
,static_cast< css::lang::XEventListener*>(static_cast< css::beans::XPropertiesChangeListener*>(this))
|
|
);
|
|
|
|
return aReturn;
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::disposing()
|
|
{
|
|
osl::MutexGuard aGuard(rBHelper.rMutex);
|
|
|
|
if ( m_xAggregateSet.is() && m_bListening )
|
|
{
|
|
// register as a single listener
|
|
m_xAggregateMultiSet->removePropertiesChangeListener(this);
|
|
m_xAggregateSet->removeVetoableChangeListener(OUString(), this);
|
|
m_bListening = false;
|
|
}
|
|
|
|
OPropertyStateHelper::disposing();
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::disposing(const css::lang::EventObject& _rSource)
|
|
{
|
|
OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::disposing : don't have an aggregate anymore !");
|
|
if (_rSource.Source == m_xAggregateSet)
|
|
m_bListening = false;
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::propertiesChange(const css::uno::Sequence< css::beans::PropertyChangeEvent>& _rEvents)
|
|
{
|
|
OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::propertiesChange : have no aggregate !");
|
|
|
|
sal_Int32 nLen = _rEvents.getLength();
|
|
cppu::IPropertyArrayHelper& rPH = getInfoHelper();
|
|
|
|
if (1 == nLen)
|
|
{
|
|
const css::beans::PropertyChangeEvent& evt = _rEvents[0];
|
|
OSL_ENSURE(!evt.PropertyName.isEmpty(), "OPropertySetAggregationHelper::propertiesChange : invalid event !");
|
|
// we had a bug where this assertion would have us saved a whole day :) (72514)
|
|
sal_Int32 nHandle = rPH.getHandleByName( evt.PropertyName );
|
|
|
|
// If nHandle is -1 the event marks a (aggregate) property which we hide to callers
|
|
// If isCurrentlyForwardingProperty( nHandle ) is <TRUE/>, then we ourself triggered
|
|
// setting this property. In this case, it will be notified later (by the OPropertySetHelper
|
|
// implementation)
|
|
|
|
if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
|
|
fire(&nHandle, &evt.NewValue, &evt.OldValue, 1, false);
|
|
}
|
|
else
|
|
{
|
|
std::unique_ptr<sal_Int32[]> pHandles(new sal_Int32[nLen]);
|
|
std::unique_ptr< css::uno::Any[]> pNewValues(new css::uno::Any[nLen]);
|
|
std::unique_ptr< css::uno::Any[]> pOldValues(new css::uno::Any[nLen]);
|
|
|
|
sal_Int32 nDest = 0;
|
|
for (const css::beans::PropertyChangeEvent& rEvent : _rEvents)
|
|
{
|
|
sal_Int32 nHandle = rPH.getHandleByName(rEvent.PropertyName);
|
|
if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
|
|
{ // same as above : -1 is valid (73247) ...
|
|
pHandles[nDest] = nHandle;
|
|
pNewValues[nDest] = rEvent.NewValue;
|
|
pOldValues[nDest] = rEvent.OldValue;
|
|
++nDest;
|
|
}
|
|
}
|
|
|
|
if (nDest)
|
|
fire(pHandles.get(), pNewValues.get(), pOldValues.get(), nDest, false);
|
|
}
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::vetoableChange(const css::beans::PropertyChangeEvent& _rEvent)
|
|
{
|
|
OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::vetoableChange : have no aggregate !");
|
|
|
|
cppu::IPropertyArrayHelper& rPH = getInfoHelper();
|
|
|
|
sal_Int32 nHandle = rPH.getHandleByName(_rEvent.PropertyName);
|
|
fire(&nHandle, &_rEvent.NewValue, &_rEvent.OldValue, 1, true);
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::setAggregation(const css::uno::Reference< css::uno::XInterface >& _rxDelegate)
|
|
{
|
|
osl::MutexGuard aGuard(rBHelper.rMutex);
|
|
|
|
if (m_bListening && m_xAggregateSet.is())
|
|
{
|
|
m_xAggregateMultiSet->removePropertiesChangeListener(this);
|
|
m_xAggregateSet->removeVetoableChangeListener(OUString(), this);
|
|
m_bListening = false;
|
|
}
|
|
|
|
m_xAggregateState.set(_rxDelegate, css::uno::UNO_QUERY);
|
|
m_xAggregateSet.set(_rxDelegate, css::uno::UNO_QUERY);
|
|
m_xAggregateMultiSet.set(_rxDelegate, css::uno::UNO_QUERY);
|
|
m_xAggregateFastSet.set(_rxDelegate, css::uno::UNO_QUERY);
|
|
|
|
// must support XPropertySet and XMultiPropertySet
|
|
if ( m_xAggregateSet.is() && !m_xAggregateMultiSet.is() )
|
|
throw css::lang::IllegalArgumentException();
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::startListening()
|
|
{
|
|
osl::MutexGuard aGuard(rBHelper.rMutex);
|
|
|
|
if (!m_bListening && m_xAggregateSet.is())
|
|
{
|
|
// register as a single listener
|
|
css::uno::Sequence< OUString > aPropertyNames;
|
|
m_xAggregateMultiSet->addPropertiesChangeListener(aPropertyNames, this);
|
|
m_xAggregateSet->addVetoableChangeListener(OUString(), this);
|
|
|
|
m_bListening = true;
|
|
}
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::addVetoableChangeListener(const OUString& _rPropertyName,
|
|
const css::uno::Reference< css::beans::XVetoableChangeListener>& _rxListener)
|
|
{
|
|
OPropertySetHelper::addVetoableChangeListener(_rPropertyName, _rxListener);
|
|
if (!m_bListening)
|
|
startListening();
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::addPropertyChangeListener(const OUString& _rPropertyName,
|
|
const css::uno::Reference< css::beans::XPropertyChangeListener>& _rxListener)
|
|
{
|
|
OPropertySetHelper::addPropertyChangeListener(_rPropertyName, _rxListener);
|
|
if (!m_bListening)
|
|
startListening();
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::addPropertiesChangeListener(const css::uno::Sequence< OUString >& _rPropertyNames,
|
|
const css::uno::Reference< css::beans::XPropertiesChangeListener>& _rxListener)
|
|
{
|
|
OPropertySetHelper::addPropertiesChangeListener(_rPropertyNames, _rxListener);
|
|
if (!m_bListening)
|
|
startListening();
|
|
}
|
|
|
|
|
|
sal_Int32 OPropertySetAggregationHelper::getOriginalHandle(sal_Int32 nHandle) const
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
|
|
sal_Int32 nOriginalHandle = -1;
|
|
(void)rPH.fillAggregatePropertyInfoByHandle(nullptr, &nOriginalHandle, nHandle);
|
|
return nOriginalHandle;
|
|
}
|
|
|
|
|
|
OUString OPropertySetAggregationHelper::getPropertyName( sal_Int32 _nHandle ) const
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
|
|
Property aProperty;
|
|
OSL_VERIFY( rPH.getPropertyByHandle( _nHandle, aProperty ) );
|
|
return aProperty.Name;
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::setFastPropertyValue(sal_Int32 _nHandle, const css::uno::Any& _rValue)
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
OUString aPropName;
|
|
sal_Int32 nOriginalHandle = -1;
|
|
|
|
// does the handle belong to the aggregation ?
|
|
if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, _nHandle))
|
|
if (m_xAggregateFastSet.is())
|
|
m_xAggregateFastSet->setFastPropertyValue(nOriginalHandle, _rValue);
|
|
else
|
|
m_xAggregateSet->setPropertyValue(aPropName, _rValue);
|
|
else
|
|
OPropertySetHelper::setFastPropertyValue(_nHandle, _rValue);
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::getFastPropertyValue( css::uno::Any& rValue, sal_Int32 nHandle) const
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
|
|
OUString aPropName;
|
|
sal_Int32 nOriginalHandle = -1;
|
|
|
|
if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
|
|
{
|
|
if (m_xAggregateFastSet.is())
|
|
rValue = m_xAggregateFastSet->getFastPropertyValue(nOriginalHandle);
|
|
else
|
|
rValue = m_xAggregateSet->getPropertyValue(aPropName);
|
|
}
|
|
else if ( m_pForwarder->isResponsibleFor( nHandle ) )
|
|
{
|
|
// this is a property which has been "overwritten" in our instance (thus
|
|
// fillAggregatePropertyInfoByHandle didn't find it)
|
|
rValue = m_xAggregateSet->getPropertyValue( getPropertyName( nHandle ) );
|
|
}
|
|
}
|
|
|
|
|
|
css::uno::Any SAL_CALL OPropertySetAggregationHelper::getFastPropertyValue(sal_Int32 nHandle)
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
OUString aPropName;
|
|
sal_Int32 nOriginalHandle = -1;
|
|
css::uno::Any aValue;
|
|
|
|
if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
|
|
{
|
|
if (m_xAggregateFastSet.is())
|
|
aValue = m_xAggregateFastSet->getFastPropertyValue(nOriginalHandle);
|
|
else
|
|
aValue = m_xAggregateSet->getPropertyValue(aPropName);
|
|
}
|
|
else
|
|
aValue = OPropertySetHelper::getFastPropertyValue(nHandle);
|
|
|
|
return aValue;
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::setPropertyValues(
|
|
const Sequence< OUString >& _rPropertyNames, const Sequence< Any >& _rValues )
|
|
{
|
|
OSL_ENSURE( !rBHelper.bInDispose, "OPropertySetAggregationHelper::setPropertyValues : do not use within the dispose call !");
|
|
OSL_ENSURE( !rBHelper.bDisposed, "OPropertySetAggregationHelper::setPropertyValues : object is disposed" );
|
|
|
|
// check where the properties come from
|
|
if (!m_xAggregateSet.is())
|
|
OPropertySetHelper::setPropertyValues(_rPropertyNames, _rValues);
|
|
else if (_rPropertyNames.getLength() == 1) // use the more efficient way
|
|
{
|
|
if (_rValues.getLength() != 1)
|
|
throw IllegalArgumentException(u"lengths do not match"_ustr, static_cast<XPropertySet*>(this),
|
|
-1);
|
|
try
|
|
{
|
|
setPropertyValue( _rPropertyNames[0], _rValues[0] );
|
|
}
|
|
catch( const UnknownPropertyException& )
|
|
{
|
|
// by definition of XMultiPropertySet::setPropertyValues, unknown properties are to be ignored
|
|
SAL_WARN( "comphelper", "OPropertySetAggregationHelper::setPropertyValues: unknown property: '"
|
|
<< _rPropertyNames[0] << "', implementation: " << typeid( *this ).name() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
|
|
// determine which properties belong to the aggregate, and which ones to the delegator
|
|
sal_Int32 nAggCount(0);
|
|
sal_Int32 nLen(_rPropertyNames.getLength());
|
|
|
|
for ( const OUString& rName : _rPropertyNames )
|
|
{
|
|
OPropertyArrayAggregationHelper::PropertyOrigin ePropOrg = rPH.classifyProperty( rName );
|
|
if ( OPropertyArrayAggregationHelper::PropertyOrigin::Unknown == ePropOrg )
|
|
throw WrappedTargetException( OUString(), static_cast< XMultiPropertySet* >( this ), Any( UnknownPropertyException( ) ) );
|
|
// due to a flaw in the API design, this method is not allowed to throw an UnknownPropertyException
|
|
// so we wrap it into a WrappedTargetException
|
|
|
|
if ( OPropertyArrayAggregationHelper::PropertyOrigin::Aggregate == ePropOrg )
|
|
++nAggCount;
|
|
}
|
|
|
|
// all properties belong to the aggregate
|
|
if (nAggCount == nLen)
|
|
m_xAggregateMultiSet->setPropertyValues(_rPropertyNames, _rValues);
|
|
|
|
// all properties belong to the aggregating object
|
|
else if (nAggCount == 0)
|
|
OPropertySetHelper::setPropertyValues(_rPropertyNames, _rValues);
|
|
|
|
// mixed
|
|
else
|
|
{
|
|
if (_rValues.getLength() != nLen)
|
|
throw IllegalArgumentException(u"lengths do not match"_ustr,
|
|
static_cast<XPropertySet*>(this), -1);
|
|
|
|
// aggregate's names
|
|
Sequence< OUString > AggPropertyNames( nAggCount );
|
|
OUString* pAggNames = AggPropertyNames.getArray();
|
|
// aggregate's values
|
|
Sequence< Any > AggValues( nAggCount );
|
|
Any* pAggValues = AggValues.getArray();
|
|
|
|
// delegator names
|
|
Sequence< OUString > DelPropertyNames( nLen - nAggCount );
|
|
OUString* pDelNames = DelPropertyNames.getArray();
|
|
|
|
// delegator values
|
|
Sequence< Any > DelValues( nLen - nAggCount );
|
|
Any* pDelValues = DelValues.getArray();
|
|
|
|
for (sal_Int32 i = 0; i < nLen; ++i)
|
|
{
|
|
if ( OPropertyArrayAggregationHelper::PropertyOrigin::Aggregate == rPH.classifyProperty( _rPropertyNames[i] ) )
|
|
{
|
|
*pAggNames++ = _rPropertyNames[i];
|
|
*pAggValues++ = _rValues[i];
|
|
}
|
|
else
|
|
{
|
|
*pDelNames++ = _rPropertyNames[i];
|
|
*pDelValues++ = _rValues[i];
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<sal_Int32[]> pHandles(new sal_Int32[ nLen - nAggCount ]);
|
|
|
|
// get the map table
|
|
cppu::IPropertyArrayHelper& rPH2 = getInfoHelper();
|
|
|
|
// fill the handle array
|
|
sal_Int32 nHitCount = rPH2.fillHandles( pHandles.get(), DelPropertyNames );
|
|
if (nHitCount != 0)
|
|
{
|
|
std::unique_ptr< css::uno::Any[]> pConvertedValues(new css::uno::Any[ nHitCount ]);
|
|
std::unique_ptr< css::uno::Any[]> pOldValues(new css::uno::Any[ nHitCount ]);
|
|
nHitCount = 0;
|
|
sal_Int32 i;
|
|
|
|
{
|
|
// must lock the mutex outside the loop. So all values are consistent.
|
|
osl::MutexGuard aGuard( rBHelper.rMutex );
|
|
for( i = 0; i < (nLen - nAggCount); ++i )
|
|
{
|
|
if( pHandles[i] != -1 )
|
|
{
|
|
sal_Int16 nAttributes;
|
|
rPH2.fillPropertyMembersByHandle( nullptr, &nAttributes, pHandles[i] );
|
|
if( nAttributes & css::beans::PropertyAttribute::READONLY )
|
|
throw css::beans::PropertyVetoException();
|
|
// Will the property change?
|
|
if( convertFastPropertyValue( pConvertedValues[ nHitCount ], pOldValues[nHitCount],
|
|
pHandles[i], DelValues[i] ) )
|
|
{
|
|
// only increment if the property really change
|
|
pHandles[nHitCount] = pHandles[i];
|
|
nHitCount++;
|
|
}
|
|
}
|
|
}
|
|
// release guard to fire events
|
|
}
|
|
|
|
// fire vetoable events
|
|
fire( pHandles.get(), pConvertedValues.get(), pOldValues.get(), nHitCount, true );
|
|
|
|
// setting the agg Properties
|
|
m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);
|
|
|
|
{
|
|
// must lock the mutex outside the loop.
|
|
osl::MutexGuard aGuard( rBHelper.rMutex );
|
|
// Loop over all changed properties
|
|
for( i = 0; i < nHitCount; i++ )
|
|
{
|
|
// Will the property change?
|
|
setFastPropertyValue_NoBroadcast( pHandles[i], pConvertedValues[i] );
|
|
}
|
|
// release guard to fire events
|
|
}
|
|
|
|
// fire change events
|
|
fire( pHandles.get(), pConvertedValues.get(), pOldValues.get(), nHitCount, false );
|
|
}
|
|
else
|
|
m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);
|
|
}
|
|
}
|
|
}
|
|
|
|
// XPropertyState
|
|
|
|
css::beans::PropertyState SAL_CALL OPropertySetAggregationHelper::getPropertyState(const OUString& _rPropertyName)
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
sal_Int32 nHandle = rPH.getHandleByName( _rPropertyName );
|
|
|
|
if (nHandle == -1)
|
|
{
|
|
throw css::beans::UnknownPropertyException(_rPropertyName);
|
|
}
|
|
|
|
OUString aPropName;
|
|
sal_Int32 nOriginalHandle = -1;
|
|
if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
|
|
{
|
|
if (m_xAggregateState.is())
|
|
return m_xAggregateState->getPropertyState(_rPropertyName);
|
|
else
|
|
return css::beans::PropertyState_DIRECT_VALUE;
|
|
}
|
|
else
|
|
return getPropertyStateByHandle(nHandle);
|
|
}
|
|
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::setPropertyToDefault(const OUString& _rPropertyName)
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
sal_Int32 nHandle = rPH.getHandleByName(_rPropertyName);
|
|
if (nHandle == -1)
|
|
{
|
|
throw css::beans::UnknownPropertyException(_rPropertyName);
|
|
}
|
|
|
|
OUString aPropName;
|
|
sal_Int32 nOriginalHandle = -1;
|
|
if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
|
|
{
|
|
if (m_xAggregateState.is())
|
|
m_xAggregateState->setPropertyToDefault(_rPropertyName);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
setPropertyToDefaultByHandle( nHandle );
|
|
}
|
|
catch( const UnknownPropertyException& ) { throw; }
|
|
catch( const RuntimeException& ) { throw; }
|
|
catch( const Exception& )
|
|
{
|
|
OSL_FAIL( "OPropertySetAggregationHelper::setPropertyToDefault: caught an exception which is not allowed to leave here!" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
css::uno::Any SAL_CALL OPropertySetAggregationHelper::getPropertyDefault(const OUString& aPropertyName)
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
sal_Int32 nHandle = rPH.getHandleByName( aPropertyName );
|
|
|
|
if ( nHandle == -1 )
|
|
throw css::beans::UnknownPropertyException(aPropertyName);
|
|
|
|
OUString aPropName;
|
|
sal_Int32 nOriginalHandle = -1;
|
|
if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
|
|
{
|
|
if (m_xAggregateState.is())
|
|
return m_xAggregateState->getPropertyDefault(aPropertyName);
|
|
else
|
|
return css::uno::Any();
|
|
}
|
|
else
|
|
return getPropertyDefaultByHandle(nHandle);
|
|
}
|
|
|
|
sal_Bool SAL_CALL OPropertySetAggregationHelper::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
|
|
{
|
|
bool bModified = false;
|
|
|
|
OSL_ENSURE( m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::convertFastPropertyValue: this is no forwarded property - did you use declareForwardedProperty for it?" );
|
|
if ( m_pForwarder->isResponsibleFor( _nHandle ) )
|
|
{
|
|
// need to determine the type of the property for conversion
|
|
OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
|
|
Property aProperty;
|
|
OSL_VERIFY( rPH.getPropertyByHandle( _nHandle, aProperty ) );
|
|
|
|
Any aCurrentValue;
|
|
getFastPropertyValue( aCurrentValue, _nHandle );
|
|
bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, aCurrentValue, aProperty.Type );
|
|
}
|
|
|
|
return bModified;
|
|
}
|
|
|
|
void SAL_CALL OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue )
|
|
{
|
|
OSL_ENSURE( m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast: this is no forwarded property - did you use declareForwardedProperty for it?" );
|
|
if ( m_pForwarder->isResponsibleFor( _nHandle ) )
|
|
m_pForwarder->doForward( _nHandle, _rValue );
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::declareForwardedProperty( sal_Int32 _nHandle )
|
|
{
|
|
OSL_ENSURE( !m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::declareForwardedProperty: already declared!" );
|
|
m_pForwarder->takeResponsibilityFor( _nHandle );
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::forwardingPropertyValue( sal_Int32 )
|
|
{
|
|
// not interested in
|
|
}
|
|
|
|
|
|
void OPropertySetAggregationHelper::forwardedPropertyValue( sal_Int32 )
|
|
{
|
|
// not interested in
|
|
}
|
|
|
|
|
|
bool OPropertySetAggregationHelper::isCurrentlyForwardingProperty( sal_Int32 _nHandle ) const
|
|
{
|
|
return m_pForwarder->getCurrentlyForwardedProperty() == _nHandle;
|
|
}
|
|
|
|
|
|
} // namespace comphelper
|
|
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|