| /************************************************************** |
| * |
| * 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_toolkit.hxx" |
| #include "toolkit/controls/geometrycontrolmodel.hxx" |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <osl/diagnose.h> |
| #include <rtl/instance.hxx> |
| #include <comphelper/property.hxx> |
| #include <comphelper/sequence.hxx> |
| #ifndef _COM_SUN_STAR_XNAMECONTAINER_HPP_ |
| #include <toolkit/controls/eventcontainer.hxx> |
| #endif |
| #include <toolkit/helper/property.hxx> |
| #include <tools/debug.hxx> |
| #include <algorithm> |
| #include <functional> |
| #include <comphelper/sequence.hxx> |
| |
| |
| #define GCM_PROPERTY_ID_POS_X 1 |
| #define GCM_PROPERTY_ID_POS_Y 2 |
| #define GCM_PROPERTY_ID_WIDTH 3 |
| #define GCM_PROPERTY_ID_HEIGHT 4 |
| #define GCM_PROPERTY_ID_NAME 5 |
| #define GCM_PROPERTY_ID_TABINDEX 6 |
| #define GCM_PROPERTY_ID_STEP 7 |
| #define GCM_PROPERTY_ID_TAG 8 |
| #define GCM_PROPERTY_ID_RESOURCERESOLVER 9 |
| |
| #define GCM_PROPERTY_POS_X ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PositionX")) |
| #define GCM_PROPERTY_POS_Y ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PositionY")) |
| #define GCM_PROPERTY_WIDTH ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Width")) |
| #define GCM_PROPERTY_HEIGHT ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Height")) |
| #define GCM_PROPERTY_NAME ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Name")) |
| #define GCM_PROPERTY_TABINDEX ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TabIndex")) |
| #define GCM_PROPERTY_STEP ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Step")) |
| #define GCM_PROPERTY_TAG ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Tag")) |
| #define GCM_PROPERTY_RESOURCERESOLVER ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ResourceResolver")) |
| |
| #define DEFAULT_ATTRIBS() PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT |
| |
| //........................................................................ |
| // namespace toolkit |
| // { |
| //........................................................................ |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::container; |
| using namespace ::comphelper; |
| |
| //==================================================================== |
| //= OGeometryControlModel_Base |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| OGeometryControlModel_Base::OGeometryControlModel_Base(::com::sun::star::uno::XAggregation* _pAggregateInstance) |
| :OPropertySetAggregationHelper( m_aBHelper ) |
| ,OPropertyContainer( m_aBHelper ) |
| ,OGCM_Base( m_aMutex ) |
| ,m_nPosX(0) |
| ,m_nPosY(0) |
| ,m_nWidth(0) |
| ,m_nHeight(0) |
| ,m_nTabIndex(-1) |
| ,m_nStep(0) |
| ,m_bCloneable(sal_False) |
| { |
| OSL_ENSURE(NULL != _pAggregateInstance, "OGeometryControlModel_Base::OGeometryControlModel_Base: invalid aggregate!"); |
| |
| increment(m_refCount); |
| { |
| m_xAggregate = _pAggregateInstance; |
| |
| { // check if the aggregat is cloneable |
| Reference< XCloneable > xCloneAccess(m_xAggregate, UNO_QUERY); |
| m_bCloneable = xCloneAccess.is(); |
| } |
| |
| setAggregation(m_xAggregate); |
| m_xAggregate->setDelegator(static_cast< XWeak* >(this)); |
| } |
| decrement(m_refCount); |
| |
| registerProperties(); |
| } |
| |
| //-------------------------------------------------------------------- |
| OGeometryControlModel_Base::OGeometryControlModel_Base(Reference< XCloneable >& _rxAggregateInstance) |
| :OPropertySetAggregationHelper( m_aBHelper ) |
| ,OPropertyContainer( m_aBHelper ) |
| ,OGCM_Base( m_aMutex ) |
| ,m_nPosX(0) |
| ,m_nPosY(0) |
| ,m_nWidth(0) |
| ,m_nHeight(0) |
| ,m_nTabIndex(-1) |
| ,m_nStep(0) |
| ,m_bCloneable(_rxAggregateInstance.is()) |
| { |
| increment(m_refCount); |
| { |
| { |
| // ensure that the temporary gets destructed NOW |
| m_xAggregate = Reference< XAggregation >(_rxAggregateInstance, UNO_QUERY); |
| } |
| OSL_ENSURE(m_xAggregate.is(), "OGeometryControlModel_Base::OGeometryControlModel_Base: invalid object given!"); |
| |
| // now the aggregate has a ref count of 2, but before setting the delegator it must be 1 |
| _rxAggregateInstance.clear(); |
| // now it should be the 1 we need here ... |
| |
| setAggregation(m_xAggregate); |
| m_xAggregate->setDelegator(static_cast< XWeak* >(this)); |
| } |
| decrement(m_refCount); |
| |
| registerProperties(); |
| } |
| |
| //-------------------------------------------------------------------- |
| Sequence< Type > SAL_CALL OGeometryControlModel_Base::getTypes( ) throw (RuntimeException) |
| { |
| // our own types |
| Sequence< Type > aTypes = ::comphelper::concatSequences( |
| OPropertySetAggregationHelper::getTypes(), |
| OPropertyContainer::getTypes(), |
| OGCM_Base::getTypes() |
| ); |
| |
| if ( m_xAggregate.is() ) |
| { |
| // retrieve the types of the aggregate |
| Reference< XTypeProvider > xAggregateTypeProv; |
| m_xAggregate->queryAggregation( ::getCppuType( &xAggregateTypeProv ) ) >>= xAggregateTypeProv; |
| OSL_ENSURE( xAggregateTypeProv.is(), "OGeometryControlModel_Base::getTypes: aggregate should be a type provider!" ); |
| Sequence< Type > aAggTypes; |
| if ( xAggregateTypeProv.is() ) |
| aAggTypes = xAggregateTypeProv->getTypes(); |
| |
| // concat the sequences |
| sal_Int32 nOldSize = aTypes.getLength(); |
| aTypes.realloc( nOldSize + aAggTypes.getLength() ); |
| ::std::copy( |
| aAggTypes.getConstArray(), |
| aAggTypes.getConstArray() + aAggTypes.getLength(), |
| aTypes.getArray() + nOldSize |
| ); |
| } |
| |
| return aTypes; |
| } |
| |
| //-------------------------------------------------------------------- |
| void OGeometryControlModel_Base::registerProperties() |
| { |
| // register our members for the property handling of the OPropertyContainer |
| registerProperty(GCM_PROPERTY_POS_X, GCM_PROPERTY_ID_POS_X, DEFAULT_ATTRIBS(), &m_nPosX, ::getCppuType(&m_nPosX)); |
| registerProperty(GCM_PROPERTY_POS_Y, GCM_PROPERTY_ID_POS_Y, DEFAULT_ATTRIBS(), &m_nPosY, ::getCppuType(&m_nPosY)); |
| registerProperty(GCM_PROPERTY_WIDTH, GCM_PROPERTY_ID_WIDTH, DEFAULT_ATTRIBS(), &m_nWidth, ::getCppuType(&m_nWidth)); |
| registerProperty(GCM_PROPERTY_HEIGHT, GCM_PROPERTY_ID_HEIGHT, DEFAULT_ATTRIBS(), &m_nHeight, ::getCppuType(&m_nHeight)); |
| registerProperty(GCM_PROPERTY_NAME, GCM_PROPERTY_ID_NAME, DEFAULT_ATTRIBS(), &m_aName, ::getCppuType(&m_aName)); |
| registerProperty(GCM_PROPERTY_TABINDEX, GCM_PROPERTY_ID_TABINDEX, DEFAULT_ATTRIBS(), &m_nTabIndex, ::getCppuType(&m_nTabIndex)); |
| registerProperty(GCM_PROPERTY_STEP, GCM_PROPERTY_ID_STEP, DEFAULT_ATTRIBS(), &m_nStep, ::getCppuType(&m_nStep)); |
| registerProperty(GCM_PROPERTY_TAG, GCM_PROPERTY_ID_TAG, DEFAULT_ATTRIBS(), &m_aTag, ::getCppuType(&m_aTag)); |
| registerProperty(GCM_PROPERTY_RESOURCERESOLVER, GCM_PROPERTY_ID_RESOURCERESOLVER, DEFAULT_ATTRIBS(), &m_xStrResolver, ::getCppuType(&m_xStrResolver)); |
| } |
| |
| //-------------------------------------------------------------------- |
| ::com::sun::star::uno::Any OGeometryControlModel_Base::ImplGetDefaultValueByHandle(sal_Int32 nHandle) const |
| { |
| ::com::sun::star::uno::Any aDefault; |
| |
| switch ( nHandle ) |
| { |
| case GCM_PROPERTY_ID_POS_X: aDefault <<= (sal_Int32) 0; break; |
| case GCM_PROPERTY_ID_POS_Y: aDefault <<= (sal_Int32) 0; break; |
| case GCM_PROPERTY_ID_WIDTH: aDefault <<= (sal_Int32) 0; break; |
| case GCM_PROPERTY_ID_HEIGHT: aDefault <<= (sal_Int32) 0; break; |
| case GCM_PROPERTY_ID_NAME: aDefault <<= ::rtl::OUString(); break; |
| case GCM_PROPERTY_ID_TABINDEX: aDefault <<= (sal_Int16) -1; break; |
| case GCM_PROPERTY_ID_STEP: aDefault <<= (sal_Int32) 0; break; |
| case GCM_PROPERTY_ID_TAG: aDefault <<= ::rtl::OUString(); break; |
| case GCM_PROPERTY_ID_RESOURCERESOLVER: aDefault <<= Reference< resource::XStringResourceResolver >(); break; |
| default: DBG_ERROR( "ImplGetDefaultValueByHandle - unknown Property" ); |
| } |
| |
| return aDefault; |
| } |
| |
| //-------------------------------------------------------------------- |
| ::com::sun::star::uno::Any OGeometryControlModel_Base::ImplGetPropertyValueByHandle(sal_Int32 nHandle) const |
| { |
| ::com::sun::star::uno::Any aValue; |
| |
| switch ( nHandle ) |
| { |
| case GCM_PROPERTY_ID_POS_X: aValue <<= m_nPosX; break; |
| case GCM_PROPERTY_ID_POS_Y: aValue <<= m_nPosY; break; |
| case GCM_PROPERTY_ID_WIDTH: aValue <<= m_nWidth; break; |
| case GCM_PROPERTY_ID_HEIGHT: aValue <<= m_nHeight; break; |
| case GCM_PROPERTY_ID_NAME: aValue <<= m_aName; break; |
| case GCM_PROPERTY_ID_TABINDEX: aValue <<= m_nTabIndex; break; |
| case GCM_PROPERTY_ID_STEP: aValue <<= m_nStep; break; |
| case GCM_PROPERTY_ID_TAG: aValue <<= m_aTag; break; |
| case GCM_PROPERTY_ID_RESOURCERESOLVER: aValue <<= m_xStrResolver; break; |
| default: DBG_ERROR( "ImplGetPropertyValueByHandle - unknown Property" ); |
| } |
| |
| return aValue; |
| } |
| |
| //-------------------------------------------------------------------- |
| void OGeometryControlModel_Base::ImplSetPropertyValueByHandle(sal_Int32 nHandle, const :: com::sun::star::uno::Any& aValue) |
| { |
| switch ( nHandle ) |
| { |
| case GCM_PROPERTY_ID_POS_X: aValue >>= m_nPosX; break; |
| case GCM_PROPERTY_ID_POS_Y: aValue >>= m_nPosY; break; |
| case GCM_PROPERTY_ID_WIDTH: aValue >>= m_nWidth; break; |
| case GCM_PROPERTY_ID_HEIGHT: aValue >>= m_nHeight; break; |
| case GCM_PROPERTY_ID_NAME: aValue >>= m_aName; break; |
| case GCM_PROPERTY_ID_TABINDEX: aValue >>= m_nTabIndex; break; |
| case GCM_PROPERTY_ID_STEP: aValue >>= m_nStep; break; |
| case GCM_PROPERTY_ID_TAG: aValue >>= m_aTag; break; |
| case GCM_PROPERTY_ID_RESOURCERESOLVER: aValue >>= m_xStrResolver; break; |
| default: DBG_ERROR( "ImplSetPropertyValueByHandle - unknown Property" ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| Any SAL_CALL OGeometryControlModel_Base::queryAggregation( const Type& _rType ) throw(RuntimeException) |
| { |
| Any aReturn; |
| if (_rType.equals(::getCppuType(static_cast< Reference< XCloneable>* >(NULL))) && !m_bCloneable) |
| // somebody is asking for the XCloneable interface, but our aggregate does not support it |
| // -> outta here |
| // (need this extra check, cause OGCM_Base::queryAggregation would return this interface |
| // in every case) |
| return aReturn; |
| |
| aReturn = OGCM_Base::queryAggregation(_rType); |
| // the basic interfaces (XInterface, XAggregation etc) |
| |
| if (!aReturn.hasValue()) |
| aReturn = OPropertySetAggregationHelper::queryInterface(_rType); |
| // the property set related interfaces |
| |
| if (!aReturn.hasValue() && m_xAggregate.is()) |
| aReturn = m_xAggregate->queryAggregation(_rType); |
| // the interfaces our aggregate can provide |
| |
| return aReturn; |
| } |
| |
| //-------------------------------------------------------------------- |
| Any SAL_CALL OGeometryControlModel_Base::queryInterface( const Type& _rType ) throw(RuntimeException) |
| { |
| return OGCM_Base::queryInterface(_rType); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL OGeometryControlModel_Base::acquire( ) throw() |
| { |
| OGCM_Base::acquire(); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL OGeometryControlModel_Base::release( ) throw() |
| { |
| OGCM_Base::release(); |
| } |
| |
| //-------------------------------------------------------------------- |
| void OGeometryControlModel_Base::releaseAggregation() |
| { |
| // release the aggregate (_before_ clearing m_xAggregate) |
| if (m_xAggregate.is()) |
| m_xAggregate->setDelegator(NULL); |
| setAggregation(NULL); |
| } |
| |
| //-------------------------------------------------------------------- |
| OGeometryControlModel_Base::~OGeometryControlModel_Base() |
| { |
| releaseAggregation(); |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Bool SAL_CALL OGeometryControlModel_Base::convertFastPropertyValue(Any& _rConvertedValue, Any& _rOldValue, |
| sal_Int32 _nHandle, const Any& _rValue) throw (IllegalArgumentException) |
| { |
| return OPropertyContainer::convertFastPropertyValue(_rConvertedValue, _rOldValue, _nHandle, _rValue); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL OGeometryControlModel_Base::setFastPropertyValue_NoBroadcast(sal_Int32 _nHandle, const Any& _rValue) throw (Exception) |
| { |
| OPropertyContainer::setFastPropertyValue_NoBroadcast(_nHandle, _rValue); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL OGeometryControlModel_Base::getFastPropertyValue(Any& _rValue, sal_Int32 _nHandle) const |
| { |
| OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>(const_cast<OGeometryControlModel_Base*>(this)->getInfoHelper()); |
| ::rtl::OUString sPropName; |
| sal_Int32 nOriginalHandle = -1; |
| |
| if (rPH.fillAggregatePropertyInfoByHandle(&sPropName, &nOriginalHandle, _nHandle)) |
| OPropertySetAggregationHelper::getFastPropertyValue(_rValue, _nHandle); |
| else |
| OPropertyContainer::getFastPropertyValue(_rValue, _nHandle); |
| } |
| |
| //-------------------------------------------------------------------- |
| ::com::sun::star::beans::PropertyState OGeometryControlModel_Base::getPropertyStateByHandle(sal_Int32 nHandle) |
| { |
| ::com::sun::star::uno::Any aValue = ImplGetPropertyValueByHandle( nHandle ); |
| ::com::sun::star::uno::Any aDefault = ImplGetDefaultValueByHandle( nHandle ); |
| |
| return CompareProperties( aValue, aDefault ) ? ::com::sun::star::beans::PropertyState_DEFAULT_VALUE : ::com::sun::star::beans::PropertyState_DIRECT_VALUE; |
| } |
| |
| //-------------------------------------------------------------------- |
| void OGeometryControlModel_Base::setPropertyToDefaultByHandle(sal_Int32 nHandle) |
| { |
| ImplSetPropertyValueByHandle( nHandle , ImplGetDefaultValueByHandle( nHandle ) ); |
| } |
| |
| //-------------------------------------------------------------------- |
| ::com::sun::star::uno::Any OGeometryControlModel_Base::getPropertyDefaultByHandle( sal_Int32 nHandle ) const |
| { |
| return ImplGetDefaultValueByHandle( nHandle ); |
| } |
| |
| //-------------------------------------------------------------------- |
| Reference< XPropertySetInfo> SAL_CALL OGeometryControlModel_Base::getPropertySetInfo() throw(RuntimeException) |
| { |
| return OPropertySetAggregationHelper::createPropertySetInfo(getInfoHelper()); |
| } |
| |
| //-------------------------------------------------------------------- |
| Reference< XCloneable > SAL_CALL OGeometryControlModel_Base::createClone( ) throw(RuntimeException) |
| { |
| OSL_ENSURE(m_bCloneable, "OGeometryControlModel_Base::createClone: invalid call!"); |
| if (!m_bCloneable) |
| return Reference< XCloneable >(); |
| |
| // let the aggregate create it's own clone |
| // the interface |
| Reference< XCloneable > xCloneAccess; |
| m_xAggregate->queryAggregation(::getCppuType(&xCloneAccess)) >>= xCloneAccess; |
| OSL_ENSURE(xCloneAccess.is(), "OGeometryControlModel_Base::createClone: suspicious aggregate!"); |
| if (!xCloneAccess.is()) |
| return Reference< XCloneable >(); |
| // the aggregate's clone |
| Reference< XCloneable > xAggregateClone = xCloneAccess->createClone(); |
| OSL_ENSURE(xAggregateClone.is(), "OGeometryControlModel_Base::createClone: suspicious return of the aggregate!"); |
| |
| // create a new wrapper aggregating this return value |
| OGeometryControlModel_Base* pOwnClone = createClone_Impl(xAggregateClone); |
| OSL_ENSURE(pOwnClone, "OGeometryControlModel_Base::createClone: invalid derivee behaviour!"); |
| OSL_ENSURE(!xAggregateClone.is(), "OGeometryControlModel_Base::createClone: invalid ctor behaviour!"); |
| // should have been reset |
| |
| // set properties |
| pOwnClone->m_nPosX = m_nPosX; |
| pOwnClone->m_nPosY = m_nPosY; |
| pOwnClone->m_nWidth = m_nWidth; |
| pOwnClone->m_nHeight = m_nHeight; |
| pOwnClone->m_aName = m_aName; |
| pOwnClone->m_nTabIndex = m_nTabIndex; |
| pOwnClone->m_nStep = m_nStep; |
| pOwnClone->m_aTag = m_aTag; |
| |
| |
| // Clone event container |
| Reference< ::com::sun::star::script::XScriptEventsSupplier > xEventsSupplier = |
| static_cast< ::com::sun::star::script::XScriptEventsSupplier* >( this ); |
| Reference< ::com::sun::star::script::XScriptEventsSupplier > xCloneEventsSupplier = |
| static_cast< ::com::sun::star::script::XScriptEventsSupplier* >( pOwnClone ); |
| |
| if( xEventsSupplier.is() && xCloneEventsSupplier.is() ) |
| { |
| Reference< XNameContainer > xEventCont = xEventsSupplier->getEvents(); |
| Reference< XNameContainer > xCloneEventCont = xCloneEventsSupplier->getEvents(); |
| |
| ::com::sun::star::uno::Sequence< ::rtl::OUString > aNames = |
| xEventCont->getElementNames(); |
| const ::rtl::OUString* pNames = aNames.getConstArray(); |
| sal_Int32 i, nNameCount = aNames.getLength(); |
| |
| for( i = 0 ; i < nNameCount ; i++ ) |
| { |
| ::rtl::OUString aName = pNames[ i ]; |
| ::com::sun::star::uno::Any aElement = xEventCont->getByName( aName ); |
| xCloneEventCont->insertByName( aName, aElement ); |
| } |
| } |
| |
| return pOwnClone; |
| } |
| |
| //-------------------------------------------------------------------- |
| Reference< XNameContainer > SAL_CALL OGeometryControlModel_Base::getEvents() throw(RuntimeException) |
| { |
| if( !mxEventContainer.is() ) |
| mxEventContainer = (XNameContainer*)new toolkit::ScriptEventContainer(); |
| return mxEventContainer; |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL OGeometryControlModel_Base::disposing() |
| { |
| OGCM_Base::disposing(); |
| OPropertySetAggregationHelper::disposing(); |
| |
| Reference<XComponent> xComp; |
| if ( query_aggregation( m_xAggregate, xComp ) ) |
| xComp->dispose(); |
| } |
| |
| //==================================================================== |
| //= OCommonGeometryControlModel |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| |
| typedef ::std::hash_map< ::rtl::OUString, sal_Int32, ::comphelper::UStringHash > HashMapString2Int; |
| typedef ::std::vector< ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > > PropSeqArray; |
| typedef ::std::vector< ::std::vector< sal_Int32 > > IntArrayArray; |
| |
| // for creating class-unique PropertySetInfo's, we need some info: |
| namespace { struct ServiceSpecifierMap : public rtl::Static< HashMapString2Int, ServiceSpecifierMap > {}; } |
| // this one maps from a String, which is the service specifier for our |
| // aggregate, to a unique id |
| |
| namespace { struct AggregateProperties : public rtl::Static< PropSeqArray, AggregateProperties > {}; } |
| // this one contains the properties which belong to all the unique ids |
| // in ServiceSpecifierMap |
| |
| namespace { struct AmbiguousPropertyIds : public rtl::Static< IntArrayArray, AmbiguousPropertyIds > {}; } |
| // the ids of the properties which we as well as our aggregate supply |
| // For such props, we let our base class handle them, and whenever such |
| // a prop is set, we forward this to our aggregate. |
| |
| // With this, we can ensure that two instances of this class share the |
| // same PropertySetInfo if and only if both aggregates have the same |
| // service specifier. |
| |
| |
| //-------------------------------------------------------------------- |
| OCommonGeometryControlModel::OCommonGeometryControlModel( Reference< XCloneable >& _rxAgg, const ::rtl::OUString& _rServiceSpecifier ) |
| :OGeometryControlModel_Base( _rxAgg ) |
| ,m_sServiceSpecifier( _rServiceSpecifier ) |
| ,m_nPropertyMapId( 0 ) |
| { |
| Reference< XPropertySetInfo > xPI; |
| if ( m_xAggregateSet.is() ) |
| xPI = m_xAggregateSet->getPropertySetInfo(); |
| if ( !xPI.is() ) |
| { |
| releaseAggregation(); |
| throw IllegalArgumentException(); |
| } |
| |
| HashMapString2Int &rMap = ServiceSpecifierMap::get(); |
| HashMapString2Int::iterator aPropMapIdPos = rMap.find( m_sServiceSpecifier ); |
| if ( rMap.end() == aPropMapIdPos ) |
| { |
| PropSeqArray &rAggProperties = AggregateProperties::get(); |
| m_nPropertyMapId = rAggProperties.size(); |
| rAggProperties.push_back( xPI->getProperties() ); |
| AmbiguousPropertyIds::get().push_back( IntArrayArray::value_type() ); |
| |
| rMap[ m_sServiceSpecifier ] = m_nPropertyMapId; |
| } |
| else |
| m_nPropertyMapId = aPropMapIdPos->second; |
| } |
| |
| //-------------------------------------------------------------------- |
| struct PropertyNameLess : public ::std::binary_function< Property, Property, bool > |
| { |
| bool operator()( const Property& _rLHS, const Property& _rRHS ) |
| { |
| return _rLHS.Name < _rRHS.Name ? true : false; |
| } |
| }; |
| |
| //-------------------------------------------------------------------- |
| struct PropertyNameEqual : public ::std::unary_function< Property, bool > |
| { |
| const ::rtl::OUString& m_rCompare; |
| PropertyNameEqual( const ::rtl::OUString& _rCompare ) : m_rCompare( _rCompare ) { } |
| |
| bool operator()( const Property& _rLHS ) |
| { |
| return _rLHS.Name == m_rCompare ? true : false; |
| } |
| }; |
| |
| //-------------------------------------------------------------------- |
| ::cppu::IPropertyArrayHelper* OCommonGeometryControlModel::createArrayHelper( sal_Int32 _nId ) const |
| { |
| OSL_ENSURE( _nId == m_nPropertyMapId, "OCommonGeometryControlModel::createArrayHelper: invalid argument!" ); |
| OSL_ENSURE( _nId < (sal_Int32)AggregateProperties::get().size(), "OCommonGeometryControlModel::createArrayHelper: invalid status info (1)!" ); |
| OSL_ENSURE( _nId < (sal_Int32)AmbiguousPropertyIds::get().size(), "OCommonGeometryControlModel::createArrayHelper: invalid status info (2)!" ); |
| |
| // our own properties |
| Sequence< Property > aProps; |
| OPropertyContainer::describeProperties( aProps ); |
| |
| // the aggregate properties |
| Sequence< Property > aAggregateProps; |
| aAggregateProps = AggregateProperties::get()[ _nId ]; |
| |
| // look for duplicates, and remember them |
| IntArrayArray::value_type& rDuplicateIds = AmbiguousPropertyIds::get()[ _nId ]; |
| // for this, sort the aggregate properties |
| ::std::sort( |
| aAggregateProps.getArray(), |
| aAggregateProps.getArray() + aAggregateProps.getLength(), |
| PropertyNameLess() |
| ); |
| const Property* pAggProps = aAggregateProps.getConstArray(); |
| const Property* pAggPropsEnd = aAggregateProps.getConstArray() + aAggregateProps.getLength(); |
| |
| // now loop through our own props |
| const Property* pProp = aProps.getConstArray(); |
| const Property* pPropEnd = aProps.getConstArray() + aProps.getLength(); |
| while ( pProp < pPropEnd ) |
| { |
| // look for the current property in the properties of our aggregate |
| const Property* pAggPropPos = ::std::find_if( pAggProps, pAggPropsEnd, PropertyNameEqual( pProp->Name ) ); |
| if ( pAggPropPos != pAggPropsEnd ) |
| { // found a duplicate |
| // -> remove from the aggregate property sequence |
| ::comphelper::removeElementAt( aAggregateProps, pAggPropPos - pAggProps ); |
| // which means we have to adjust the pointers |
| pAggProps = aAggregateProps.getConstArray(), |
| pAggPropsEnd = aAggregateProps.getConstArray() + aAggregateProps.getLength(), |
| |
| // and additionally, remember the id of this property |
| rDuplicateIds.push_back( pProp->Handle ); |
| } |
| |
| ++pProp; |
| } |
| |
| // now, finally, sort the duplicates |
| ::std::sort( rDuplicateIds.begin(), rDuplicateIds.end(), ::std::less< sal_Int32 >() ); |
| |
| return new OPropertyArrayAggregationHelper(aProps, aAggregateProps); |
| } |
| |
| //-------------------------------------------------------------------- |
| ::cppu::IPropertyArrayHelper& SAL_CALL OCommonGeometryControlModel::getInfoHelper() |
| { |
| return *getArrayHelper( m_nPropertyMapId ); |
| } |
| |
| //-------------------------------------------------------------------- |
| OGeometryControlModel_Base* OCommonGeometryControlModel::createClone_Impl( Reference< XCloneable >& _rxAggregateInstance ) |
| { |
| return new OCommonGeometryControlModel( _rxAggregateInstance, m_sServiceSpecifier ); |
| } |
| |
| //-------------------------------------------------------------------- |
| Sequence< sal_Int8 > SAL_CALL OCommonGeometryControlModel::getImplementationId( ) throw (RuntimeException) |
| { |
| static ::cppu::OImplementationId * pId = NULL; |
| if ( !pId ) |
| { |
| ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); |
| if ( !pId ) |
| { |
| static ::cppu::OImplementationId s_aId; |
| pId = &s_aId; |
| } |
| } |
| return pId->getImplementationId(); |
| } |
| |
| //-------------------------------------------------------------------- |
| struct Int32Equal : public ::std::unary_function< sal_Int32, bool > |
| { |
| sal_Int32 m_nCompare; |
| Int32Equal( sal_Int32 _nCompare ) : m_nCompare( _nCompare ) { } |
| |
| bool operator()( sal_Int32 _nLHS ) |
| { |
| return _nLHS == m_nCompare ? true : false; |
| } |
| }; |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL OCommonGeometryControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue ) throw ( Exception ) |
| { |
| OGeometryControlModel_Base::setFastPropertyValue_NoBroadcast( _nHandle, _rValue ); |
| |
| // look if this id is one we recognized as duplicate |
| IntArrayArray::value_type& rDuplicateIds = AmbiguousPropertyIds::get()[ m_nPropertyMapId ]; |
| |
| IntArrayArray::value_type::const_iterator aPos = ::std::find_if( |
| rDuplicateIds.begin(), |
| rDuplicateIds.end(), |
| Int32Equal( _nHandle ) |
| ); |
| |
| if ( rDuplicateIds.end() != aPos ) |
| { |
| // yes, it is such a property |
| ::rtl::OUString sPropName; |
| sal_Int16 nAttributes(0); |
| static_cast< OPropertyArrayAggregationHelper* >( getArrayHelper( m_nPropertyMapId ) )->fillPropertyMembersByHandle( &sPropName, &nAttributes, _nHandle ); |
| |
| if ( m_xAggregateSet.is() && sPropName.getLength() ) |
| m_xAggregateSet->setPropertyValue( sPropName, _rValue ); |
| } |
| } |
| |
| //........................................................................ |
| // } // namespace toolkit |
| //........................................................................ |