/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_comphelper.hxx"
#include "comphelper/propagg.hxx"
#include "comphelper/property.hxx"
#include <cppuhelper/queryinterface.hxx>
#include <osl/diagnose.h>
#include <com/sun/star/beans/PropertyAttribute.hpp>

#if OSL_DEBUG_LEVEL > 0
#include <typeinfo>
#include <rtl/strbuf.hxx>
#endif

#include <algorithm>
#include <set>

//.........................................................................
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 Sequence< Property >& _rProps, const ::rtl::OUString& _rName )
		{
			sal_Int32 nLen = _rProps.getLength();
			const Property* pProperties = _rProps.getConstArray();
			const Property* pResult = ::std::lower_bound(pProperties, pProperties + nLen,_rName, ::comphelper::PropertyStringLessFunctor());
			if ( pResult && ( pResult == pProperties + nLen || pResult->Name != _rName) )
				pResult = NULL;

			return pResult;
		}
	}
//==================================================================
//= OPropertyArrayAggregationHelper
//==================================================================

//------------------------------------------------------------------------------
OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper(
		const  Sequence< Property >& _rProperties, const  Sequence< Property >& _rAggProperties,
		IPropertyInfoService* _pInfoService, sal_Int32 _nFirstAggregateId )
	:m_aProperties( _rProperties )
{
	sal_Int32 nDelegatorProps = _rProperties.getLength();
	sal_Int32 nAggregateProps = _rAggProperties.getLength();

	// make room for all properties
	sal_Int32 nMergedProps = nDelegatorProps + nAggregateProps;
	m_aProperties.realloc( nMergedProps );

	const	Property* pAggregateProps	= _rAggProperties.getConstArray();
	const	Property* pDelegateProps	= _rProperties.getConstArray();
			Property* pMergedProps = m_aProperties.getArray();

    // if properties are present both at the delegatee and the aggregate, then the former are supposed to win.
    // So, we'll need an existence check.
    ::std::set< ::rtl::OUString > aDelegatorProps;

	// create the map for the delegator properties
	sal_Int32 nMPLoop = 0;
	for ( ; nMPLoop < nDelegatorProps; ++nMPLoop, ++pDelegateProps )
    {
		m_aPropertyAccessors[ pDelegateProps->Handle ] = OPropertyAccessor( -1, nMPLoop, sal_False );
        OSL_ENSURE( aDelegatorProps.find( pDelegateProps->Name ) == aDelegatorProps.end(),
            "OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper: duplicate delegatee property!" );
        aDelegatorProps.insert( pDelegateProps->Name );
    }

	// create the map for the aggregate properties
	sal_Int32 nAggregateHandle = _nFirstAggregateId;
	pMergedProps += nDelegatorProps;
	for ( ; nMPLoop < nMergedProps; ++pAggregateProps )
	{
        // if the aggregate property is present at the delegatee already, ignore it
        if ( aDelegatorProps.find( pAggregateProps->Name ) != aDelegatorProps.end() )
        {
            --nMergedProps;
            continue;
        }

		// next aggregate property - remember it
		*pMergedProps = *pAggregateProps;

		// determine the handle for the property which we will expose to the outside world
		sal_Int32 nHandle = -1;
		// ask the infor service first
		if ( _pInfoService )
			nHandle = _pInfoService->getPreferedPropertyId( pMergedProps->Name );

		if ( -1 == nHandle )
			// no handle from the info service -> default
			nHandle = nAggregateHandle++;
		else
		{	// check if we alread have a property with the given handle
			const  Property* pPropsTilNow = m_aProperties.getConstArray();
			for ( sal_Int32 nCheck = 0; nCheck < nMPLoop; ++nCheck, ++pPropsTilNow )
				if ( pPropsTilNow->Handle == nHandle )
				{	// conflicts -> use another one (which we don't check anymore, assuming _nFirstAggregateId was large enough)
					nHandle = nAggregateHandle++;
					break;
				}
		}

		// remember the accessor for this property
		m_aPropertyAccessors[ nHandle ] = OPropertyAccessor( pMergedProps->Handle, nMPLoop, sal_True );
		pMergedProps->Handle = nHandle;

        ++nMPLoop;
        ++pMergedProps;
	}
    m_aProperties.realloc( nMergedProps );
	pMergedProps = m_aProperties.getArray();	// reset, needed again below

	// sortieren der Properties nach Namen
	::std::sort( pMergedProps, pMergedProps+nMergedProps, PropertyCompareByName());

	pMergedProps = m_aProperties.getArray();

	// Positionen in der Map abgleichen
	for ( nMPLoop = 0; nMPLoop < nMergedProps; ++nMPLoop, ++pMergedProps )
		m_aPropertyAccessors[ pMergedProps->Handle ].nPos = nMPLoop;
}

//------------------------------------------------------------------
OPropertyArrayAggregationHelper::PropertyOrigin OPropertyArrayAggregationHelper::classifyProperty( const ::rtl::OUString& _rName )
{
	PropertyOrigin eOrigin = UNKNOWN_PROPERTY;
	// look up the name
	const Property* pPropertyDescriptor = lcl_findPropertyByName( m_aProperties, _rName );
	if ( pPropertyDescriptor )
	{
		// look up the handle for this name
		ConstPropertyAccessorMapIterator 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 ? AGGREGATE_PROPERTY : DELEGATOR_PROPERTY;
		}
	}
	return eOrigin;
}

//------------------------------------------------------------------
Property OPropertyArrayAggregationHelper::getPropertyByName( const ::rtl::OUString& _rPropertyName ) throw( UnknownPropertyException )
{
	const Property* pProperty = findPropertyByName( _rPropertyName );

	if ( !pProperty )
		throw  UnknownPropertyException();

	return *pProperty;
}

//------------------------------------------------------------------------------
sal_Bool OPropertyArrayAggregationHelper::hasPropertyByName(const ::rtl::OUString& _rPropertyName)
{
	return NULL != findPropertyByName( _rPropertyName );
}

//------------------------------------------------------------------------------
const Property* OPropertyArrayAggregationHelper::findPropertyByName(const :: rtl::OUString& _rName ) const
{
	return lcl_findPropertyByName( m_aProperties, _rName );
}

//------------------------------------------------------------------------------
sal_Int32 OPropertyArrayAggregationHelper::getHandleByName(const ::rtl::OUString& _rPropertyName)
{
	const Property* pProperty = findPropertyByName( _rPropertyName );
	return pProperty ? pProperty->Handle : -1;
}

//------------------------------------------------------------------------------
sal_Bool OPropertyArrayAggregationHelper::fillPropertyMembersByHandle(
			::rtl::OUString* _pPropName, sal_Int16* _pAttributes, sal_Int32 _nHandle)
{
	ConstPropertyAccessorMapIterator i = m_aPropertyAccessors.find(_nHandle);
	sal_Bool bRet = i != m_aPropertyAccessors.end();
	if (bRet)
	{
		const  ::com::sun::star::beans::Property& rProperty = m_aProperties.getConstArray()[(*i).second.nPos];
		if (_pPropName)
			*_pPropName = rProperty.Name;
		if (_pAttributes)
			*_pAttributes = rProperty.Attributes;
	}
	return bRet;
}

//------------------------------------------------------------------------------
sal_Bool OPropertyArrayAggregationHelper::getPropertyByHandle( sal_Int32 _nHandle, Property& _rProperty ) const
{
	ConstPropertyAccessorMapIterator pos = m_aPropertyAccessors.find(_nHandle);
	if ( pos != m_aPropertyAccessors.end() )
    {
        _rProperty = m_aProperties[ pos->second.nPos ];
        return sal_True;
    }
    return sal_False;
}

//------------------------------------------------------------------------------
sal_Bool OPropertyArrayAggregationHelper::fillAggregatePropertyInfoByHandle(
			::rtl::OUString* _pPropName, sal_Int32* _pOriginalHandle, sal_Int32 _nHandle) const
{
	ConstPropertyAccessorMapIterator i = m_aPropertyAccessors.find(_nHandle);
	sal_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.getLength(),"Invalid index for sequence!");
			const  ::com::sun::star::beans::Property& rProperty = m_aProperties.getConstArray()[(*i).second.nPos];
			*_pPropName = rProperty.Name;
		}
	}
	return bRet;
}


//------------------------------------------------------------------------------
 ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property> OPropertyArrayAggregationHelper::getProperties()
{
	return m_aProperties;
}


//------------------------------------------------------------------------------
sal_Int32 OPropertyArrayAggregationHelper::fillHandles(
		sal_Int32* _pHandles, const  ::com::sun::star::uno::Sequence< ::rtl::OUString >& _rPropNames )
{
	sal_Int32 nHitCount = 0;
	const ::rtl::OUString* pReqProps = _rPropNames.getConstArray();
	sal_Int32 nReqLen = _rPropNames.getLength();

#if OSL_DEBUG_LEVEL > 0
	// assure that the sequence is sorted
	{
		const ::rtl::OUString* pLookup = _rPropNames.getConstArray();
		const ::rtl::OUString* pEnd = _rPropNames.getConstArray() + _rPropNames.getLength() - 1;
		for (; pLookup < pEnd; ++pLookup)
		{
			const ::rtl::OUString* pCompare = pLookup + 1;
			const ::rtl::OUString* pCompareEnd = pEnd + 1;
			for (; pCompare < pCompareEnd; ++pCompare)
			{
				OSL_ENSURE(pLookup->compareTo(*pCompare) < 0, "OPropertyArrayAggregationHelper::fillHandles : property names are not sorted!");
			}
		}
	}
#endif

	const  ::com::sun::star::beans::Property* pCur = m_aProperties.getConstArray();
	const  ::com::sun::star::beans::Property* pEnd = m_aProperties.getConstArray() + m_aProperties.getLength();

	for( sal_Int32 i = 0; i < nReqLen; ++i )
	{
		// Logarithmus ermitteln
		sal_uInt32 n = (sal_uInt32)(pEnd - pCur);
		sal_Int32 nLog = 0;
		while( n )
		{
			nLog += 1;
			n = n >> 1;
		}

		// Anzahl der noch zu suchenden Properties * dem Log2 der verbleibenden
		// zu dursuchenden Properties.
		if( (nReqLen - i) * nLog >= pEnd - pCur )
		{
			// linear search is better
			while( pCur < pEnd && pReqProps[i] > pCur->Name )
			{
				pCur++;
			}
			if( pCur < pEnd && pReqProps[i] == pCur->Name )
			{
				_pHandles[i] = pCur->Handle;
				nHitCount++;
			}
			else
				_pHandles[i] = -1;
		}
		else
		{
			// binary search is better
			sal_Int32	nCompVal = 1;
			const  ::com::sun::star::beans::Property*  pOldEnd = pEnd--;
			const  ::com::sun::star::beans::Property*  pMid = pCur;

			while( nCompVal != 0 && pCur <= pEnd )
			{
				pMid = (pEnd - pCur) / 2 + pCur;

				nCompVal = pReqProps[i].compareTo( pMid->Name );

				if( nCompVal > 0 )
					pCur = pMid + 1;
				else
					pEnd = pMid - 1;
			}

			if( nCompVal == 0 )
			{
				_pHandles[i] = pMid->Handle;
				nHitCount++;
				pCur = pMid +1;
			}
			else if( nCompVal > 0 )
			{
				_pHandles[i] = -1;
				pCur = pMid + 1;
			}
			else
			{
				_pHandles[i] = -1;
				pCur = pMid;
			}
			pEnd = pOldEnd;
		}
	}
	return nHitCount;
}

//==================================================================
//= PropertyForwarder
//==================================================================
namespace internal
{
    class PropertyForwarder
    {
    private:
        OPropertySetAggregationHelper&  m_rAggregationHelper;
        ::std::set< sal_Int32 >         m_aProperties;
        sal_Int32                       m_nCurrentlyForwarding;

    public:
        PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper );
        ~PropertyForwarder();

        /** 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 );

        /// actually forwards a property value to the aggregate
        void    doForward( sal_Int32 _nHandle, const Any& _rValue ) throw ( Exception );

        sal_Int32 getCurrentlyForwardedProperty( ) const { return m_nCurrentlyForwarding; }
    };

    //--------------------------------------------------------------------------
    PropertyForwarder::PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper )
        :m_rAggregationHelper( _rAggregationHelper )
        ,m_nCurrentlyForwarding( -1 )
    {
    }

    //--------------------------------------------------------------------------
    PropertyForwarder::~PropertyForwarder()
    {
    }

    //--------------------------------------------------------------------------
    void PropertyForwarder::takeResponsibilityFor( sal_Int32 _nHandle )
    {
        m_aProperties.insert( _nHandle );
    }

    //--------------------------------------------------------------------------
    bool PropertyForwarder::isResponsibleFor( sal_Int32 _nHandle )
    {
        return m_aProperties.find( _nHandle ) != m_aProperties.end();
    }

    //--------------------------------------------------------------------------
    void PropertyForwarder::doForward( sal_Int32 _nHandle, const Any& _rValue ) throw ( Exception )
    {
        OSL_ENSURE( m_rAggregationHelper.m_xAggregateSet.is(), "PropertyForwarder::doForward: no property set!" );
        if ( m_rAggregationHelper.m_xAggregateSet.is() )
        {
            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, false );
                throw;
            }

            m_nCurrentlyForwarding = -1;

            m_rAggregationHelper.forwardedPropertyValue( _nHandle, true );
        }
    }
}

//==================================================================
//= OPropertySetAggregationHelper
//==================================================================

//------------------------------------------------------------------------------
OPropertySetAggregationHelper::OPropertySetAggregationHelper( ::cppu::OBroadcastHelper& rBHlp )
    :OPropertyStateHelper( rBHlp )
    ,m_bListening( sal_False )
{
    m_pForwarder = new PropertyForwarder( *this );
}

//------------------------------------------------------------------------------
OPropertySetAggregationHelper::~OPropertySetAggregationHelper()
{
    delete m_pForwarder;
}

//------------------------------------------------------------------------------
 ::com::sun::star::uno::Any SAL_CALL OPropertySetAggregationHelper::queryInterface(const  ::com::sun::star::uno::Type& _rType) throw( ::com::sun::star::uno::RuntimeException)
{
	 ::com::sun::star::uno::Any aReturn = OPropertyStateHelper::queryInterface(_rType);

	if ( !aReturn.hasValue() )
		aReturn = cppu::queryInterface(_rType
		,static_cast< ::com::sun::star::beans::XPropertiesChangeListener*>(this)
		,static_cast< ::com::sun::star::beans::XVetoableChangeListener*>(this)
		,static_cast< ::com::sun::star::lang::XEventListener*>(static_cast< ::com::sun::star::beans::XPropertiesChangeListener*>(this))
		);

	return aReturn;
}

//------------------------------------------------------------------------------
void OPropertySetAggregationHelper::disposing()
{
	osl::MutexGuard aGuard(rBHelper.rMutex);

	if ( m_xAggregateSet.is() && m_bListening )
	{
		// als einziger Listener anmelden
		m_xAggregateMultiSet->removePropertiesChangeListener(this);
		m_xAggregateSet->removeVetoableChangeListener(::rtl::OUString(), this);
		m_bListening = sal_False;
	}

	OPropertyStateHelper::disposing();
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::disposing(const  ::com::sun::star::lang::EventObject& _rSource) throw ( ::com::sun::star::uno::RuntimeException)
{
	OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::disposing : don't have an aggregate anymore !");
	if (_rSource.Source == m_xAggregateSet)
		m_bListening = sal_False;
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::propertiesChange(const  ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyChangeEvent>& _rEvents) throw( ::com::sun::star::uno::RuntimeException)
{
	OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::propertiesChange : have no aggregate !");

	sal_Int32 nLen = _rEvents.getLength();
	cppu::IPropertyArrayHelper& rPH = getInfoHelper();

	if (1 == nLen)
	{
		const  ::com::sun::star::beans::PropertyChangeEvent& evt = _rEvents.getConstArray()[0];
		OSL_ENSURE(evt.PropertyName.getLength() > 0, "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, sal_False);
	}
	else
	{
		sal_Int32* pHandles = new sal_Int32[nLen];
		 ::com::sun::star::uno::Any* pNewValues = new  ::com::sun::star::uno::Any[nLen];
		 ::com::sun::star::uno::Any* pOldValues = new  ::com::sun::star::uno::Any[nLen];

		const  ::com::sun::star::beans::PropertyChangeEvent* pEvents = _rEvents.getConstArray();
		sal_Int32 nDest = 0;
		for (sal_Int32 nSource=0; nSource<nLen; ++nSource, ++pEvents)
		{
			sal_Int32 nHandle = rPH.getHandleByName(pEvents->PropertyName);
		    if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
			{	// same as above : -1 is valid (73247) ...
				pHandles[nDest] = nHandle;
				pNewValues[nDest] = pEvents->NewValue;
				pOldValues[nDest] = pEvents->OldValue;
				++nDest;
			}
		}

		if (nDest)
			fire(pHandles, pNewValues, pOldValues, nDest, sal_False);

		delete[] pHandles;
		delete[] pNewValues;
		delete[] pOldValues;
	}
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::vetoableChange(const  ::com::sun::star::beans::PropertyChangeEvent& _rEvent) throw( ::com::sun::star::beans::PropertyVetoException,  ::com::sun::star::uno::RuntimeException)
{
	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, sal_True);
}

//------------------------------------------------------------------------------
void OPropertySetAggregationHelper::setAggregation(const  ::com::sun::star::uno::Reference<  ::com::sun::star::uno::XInterface >& _rxDelegate)
		throw(  ::com::sun::star::lang::IllegalArgumentException )
{
	osl::MutexGuard aGuard(rBHelper.rMutex);

	if (m_bListening && m_xAggregateSet.is())
	{
		m_xAggregateMultiSet->removePropertiesChangeListener(this);
		m_xAggregateSet->removeVetoableChangeListener(::rtl::OUString(), this);
		m_bListening = sal_False;
	}

	m_xAggregateState		=  m_xAggregateState.query( _rxDelegate );
	m_xAggregateSet			=  m_xAggregateSet.query( _rxDelegate );
	m_xAggregateMultiSet	=  m_xAggregateMultiSet.query( _rxDelegate );
	m_xAggregateFastSet		=  m_xAggregateFastSet.query( _rxDelegate );

	// must support XPropertySet and XMultiPropertySet
	if ( m_xAggregateSet.is() && !m_xAggregateMultiSet.is() )
		throw  ::com::sun::star::lang::IllegalArgumentException();
}

//------------------------------------------------------------------------------
void OPropertySetAggregationHelper::startListening()
{
	osl::MutexGuard aGuard(rBHelper.rMutex);

	if (!m_bListening && m_xAggregateSet.is())
	{
		// als einziger Listener anmelden
		 ::com::sun::star::uno::Sequence< ::rtl::OUString > aPropertyNames;
		m_xAggregateMultiSet->addPropertiesChangeListener(aPropertyNames, this);
		m_xAggregateSet->addVetoableChangeListener(::rtl::OUString(), this);

		m_bListening = sal_True;
	}
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::addVetoableChangeListener(const ::rtl::OUString& _rPropertyName,
																	   const  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XVetoableChangeListener>& _rxListener)
																	   throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::lang::WrappedTargetException,  ::com::sun::star::uno::RuntimeException)
{
	OPropertySetHelper::addVetoableChangeListener(_rPropertyName, _rxListener);
	if (!m_bListening)
		startListening();
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::addPropertyChangeListener(const ::rtl::OUString& _rPropertyName,
																	   const  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener>& _rxListener)
																	   throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::lang::WrappedTargetException,  ::com::sun::star::uno::RuntimeException)
{
	OPropertySetHelper::addPropertyChangeListener(_rPropertyName, _rxListener);
	if (!m_bListening)
		startListening();
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::addPropertiesChangeListener(const  ::com::sun::star::uno::Sequence< ::rtl::OUString >& _rPropertyNames,
																		 const  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertiesChangeListener>& _rxListener)
																		 throw( ::com::sun::star::uno::RuntimeException)
{
	OPropertySetHelper::addPropertiesChangeListener(_rPropertyNames, _rxListener);
	if (!m_bListening)
		startListening();
}

//------------------------------------------------------------------------------
sal_Int32 OPropertySetAggregationHelper::getOriginalHandle(sal_Int32 nHandle) const
{
	OPropertyArrayAggregationHelper& rPH = (OPropertyArrayAggregationHelper&)const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper();
	sal_Int32 nOriginalHandle = -1;
	rPH.fillAggregatePropertyInfoByHandle(NULL, &nOriginalHandle, nHandle);
	return nOriginalHandle;
}

//--------------------------------------------------------------------------
::rtl::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  ::com::sun::star::uno::Any& _rValue)
		throw(	 ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::beans::PropertyVetoException,
				 ::com::sun::star::lang::IllegalArgumentException,  ::com::sun::star::lang::WrappedTargetException,
				 ::com::sun::star::uno::RuntimeException)
{
	OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
	::rtl::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( ::com::sun::star::uno::Any& rValue, sal_Int32 nHandle) const
{
	OPropertyArrayAggregationHelper& rPH = (OPropertyArrayAggregationHelper&)const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper();
	::rtl::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 ) );
    }
}

//------------------------------------------------------------------------------
 ::com::sun::star::uno::Any SAL_CALL OPropertySetAggregationHelper::getFastPropertyValue(sal_Int32 nHandle)
		throw(	 ::com::sun::star::beans::UnknownPropertyException,
				 ::com::sun::star::lang::WrappedTargetException,
				 ::com::sun::star::uno::RuntimeException)
{
	OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
	::rtl::OUString aPropName;
	sal_Int32	nOriginalHandle = -1;
	 ::com::sun::star::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< ::rtl::OUString >& _rPropertyNames, const Sequence< Any >& _rValues )
	throw ( PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException )
{
	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
    {
        try
        {
		    setPropertyValue( _rPropertyNames[0], _rValues[0] );
        }
        catch( const UnknownPropertyException& )
        {
            // by definition of XMultiPropertySet::setPropertyValues, unknown properties are to be ignored
        #if OSL_DEBUG_LEVEL > 0
            ::rtl::OStringBuffer aMessage;
            aMessage.append( "OPropertySetAggregationHelper::setPropertyValues: unknown property '" );
            aMessage.append( ::rtl::OUStringToOString( _rPropertyNames[0], RTL_TEXTENCODING_ASCII_US ) );
            aMessage.append( "'" );
            aMessage.append( "\n(implementation " );
            aMessage.append( typeid( *this ).name() );
            aMessage.append( ")" );
            OSL_ENSURE( false, aMessage.getStr() );
        #endif
        }
    }
	else
	{
		OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );

		// determine which properties belong to the aggregate, and which ones to the delegator
		const ::rtl::OUString* pNames = _rPropertyNames.getConstArray();
		sal_Int32 nAggCount(0);
		sal_Int32 nLen(_rPropertyNames.getLength());

		for ( sal_Int32 i = 0; i < nLen; ++i, ++pNames )
		{
			OPropertyArrayAggregationHelper::PropertyOrigin ePropOrg = rPH.classifyProperty( *pNames );
			if ( OPropertyArrayAggregationHelper::UNKNOWN_PROPERTY == ePropOrg )
				throw WrappedTargetException( ::rtl::OUString(), static_cast< XMultiPropertySet* >( this ), makeAny( 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
				// #107545# - 2002-02-20 - fs@openoffice.org

			if ( OPropertyArrayAggregationHelper::AGGREGATE_PROPERTY == ePropOrg )
				++nAggCount;
		}

		pNames = _rPropertyNames.getConstArray();	// reset, we'll need it again below ...

		// 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
		{
			const  ::com::sun::star::uno::Any* pValues = _rValues.getConstArray();
			 ::com::sun::star::uno::Any* pConvertedValues = NULL;
			 ::com::sun::star::uno::Any* pOldValues = NULL;
			sal_Int32*	pHandles = NULL;

			try
			{
				// dividing the Names and _rValues

				// aggregate's names
				Sequence< ::rtl::OUString > AggPropertyNames( nAggCount );
				::rtl::OUString* pAggNames = AggPropertyNames.getArray();
				// aggregate's values
				Sequence< Any >  AggValues( nAggCount );
				Any* pAggValues = AggValues.getArray();

				// delegator names
				Sequence< ::rtl::OUString > DelPropertyNames( nLen - nAggCount );
				::rtl::OUString* pDelNames = DelPropertyNames.getArray();

				// delegator values
				Sequence< Any > DelValues( nLen - nAggCount );
				Any* pDelValues = DelValues.getArray();

				for ( sal_Int32 i = 0; i < nLen; ++i, ++pNames, ++pValues )
				{
					if ( OPropertyArrayAggregationHelper::AGGREGATE_PROPERTY == rPH.classifyProperty( *pNames ) )
					{
						*pAggNames++ = *pNames;
						*pAggValues++ = *pValues;
					}
					else
					{
						*pDelNames++ = *pNames;
						*pDelValues++ = *pValues;
					}
				}

				// reset, needed below
				pDelValues = DelValues.getArray();

				pHandles = new sal_Int32[ nLen - nAggCount ];

				// get the map table
				cppu::IPropertyArrayHelper& rPH2 = getInfoHelper();

				// fill the handle array
				sal_Int32 nHitCount = rPH2.fillHandles( pHandles, DelPropertyNames );
				if (nHitCount != 0)
				{

					 pConvertedValues = new  ::com::sun::star::uno::Any[ nHitCount ];
					 pOldValues = new  ::com::sun::star::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( NULL, &nAttributes, pHandles[i] );
								if( nAttributes &  ::com::sun::star::beans::PropertyAttribute::READONLY )
									throw  ::com::sun::star::beans::PropertyVetoException();
								// Will the property change?
								if( convertFastPropertyValue( pConvertedValues[ nHitCount ], pOldValues[nHitCount],
															pHandles[i], pDelValues[i] ) )
								{
									// only increment if the property really change
									pHandles[nHitCount]			= pHandles[i];
									nHitCount++;
								}
							}
						}
					// release guard to fire events
					}

					// fire vetoable events
					fire( pHandles, pConvertedValues, pOldValues, nHitCount, sal_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, pConvertedValues, pOldValues, nHitCount, sal_False );
				}
				else
					m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);

			}
			catch(::com::sun::star::uno::Exception&)
			{
				delete [] pHandles;
				delete [] pOldValues;
				delete [] pConvertedValues;
				throw;
			}

			delete [] pHandles;
			delete [] pOldValues;
			delete [] pConvertedValues;
		}
	}
}

// XPropertyState
//------------------------------------------------------------------------------
 ::com::sun::star::beans::PropertyState SAL_CALL OPropertySetAggregationHelper::getPropertyState(const ::rtl::OUString& _rPropertyName)
			throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::uno::RuntimeException)
{
	OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
	sal_Int32 nHandle = rPH.getHandleByName( _rPropertyName );

	if (nHandle == -1)
	{
		throw  ::com::sun::star::beans::UnknownPropertyException();
	}

	::rtl::OUString aPropName;
	sal_Int32	nOriginalHandle = -1;
	if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
	{
		if (m_xAggregateState.is())
			return m_xAggregateState->getPropertyState(_rPropertyName);
		else
			return  ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
	}
	else
		return getPropertyStateByHandle(nHandle);
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::setPropertyToDefault(const ::rtl::OUString& _rPropertyName)
		throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::uno::RuntimeException)
{
	OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
	sal_Int32 nHandle = rPH.getHandleByName(_rPropertyName);
	if (nHandle == -1)
	{
		throw  ::com::sun::star::beans::UnknownPropertyException();
	}

	::rtl::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_ENSURE( sal_False, "OPropertySetAggregationHelper::setPropertyToDefault: caught an exception which is not allowed to leave here!" );
        }
    }
}

//------------------------------------------------------------------------------
 ::com::sun::star::uno::Any SAL_CALL OPropertySetAggregationHelper::getPropertyDefault(const ::rtl::OUString& aPropertyName)
		throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::lang::WrappedTargetException,  ::com::sun::star::uno::RuntimeException)
{
	OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
	sal_Int32 nHandle = rPH.getHandleByName( aPropertyName );

	if ( nHandle == -1 )
		throw  ::com::sun::star::beans::UnknownPropertyException();

	::rtl::OUString aPropName;
	sal_Int32	nOriginalHandle = -1;
	if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
	{
		if (m_xAggregateState.is())
			return m_xAggregateState->getPropertyDefault(aPropertyName);
		else
			return  ::com::sun::star::uno::Any();
	}
	else
		return getPropertyDefaultByHandle(nHandle);
}

//------------------------------------------------------------------------------
sal_Bool SAL_CALL OPropertySetAggregationHelper::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue ) throw(IllegalArgumentException)
{
    sal_Bool bModified = sal_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 ) throw ( Exception )
{
    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 SAL_CALL OPropertySetAggregationHelper::forwardingPropertyValue( sal_Int32 )
{
    // not interested in
}

//------------------------------------------------------------------------------
void SAL_CALL OPropertySetAggregationHelper::forwardedPropertyValue( sal_Int32, bool )
{
    // not interested in
}

//------------------------------------------------------------------------------
bool OPropertySetAggregationHelper::isCurrentlyForwardingProperty( sal_Int32 _nHandle ) const
{
    return m_pForwarder->getCurrentlyForwardedProperty() == _nHandle;
}

//.........................................................................
}	// namespace comphelper
//.........................................................................