diff options
Diffstat (limited to 'extensions/source/propctrlr/eformshelper.cxx')
| -rw-r--r-- | extensions/source/propctrlr/eformshelper.cxx | 790 |
1 files changed, 790 insertions, 0 deletions
diff --git a/extensions/source/propctrlr/eformshelper.cxx b/extensions/source/propctrlr/eformshelper.cxx new file mode 100644 index 000000000000..d4adaf3281f1 --- /dev/null +++ b/extensions/source/propctrlr/eformshelper.cxx @@ -0,0 +1,790 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_extensions.hxx" +#include "eformshelper.hxx" +#include "formstrings.hxx" +#ifndef _EXTENSIONS_FORMCTRLR_PROPRESID_HRC_ +#include "formresid.hrc" +#endif +#ifndef _EXTENSIONS_PROPCTRLR_MODULEPRC_HXX_ +#include "modulepcr.hxx" +#endif +#include "propeventtranslation.hxx" +#include "formbrowsertools.hxx" + +/** === begin UNO includes === **/ +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/xforms/XFormsUIHelper1.hpp> +#include <com/sun/star/xsd/DataTypeClass.hpp> +#include <com/sun/star/form/binding/XListEntrySink.hpp> +/** === end UNO includes === **/ +#include <tools/diagnose_ex.h> +#include <rtl/ustrbuf.hxx> + +#include <functional> +#include <algorithm> + +//........................................................................ +namespace pcr +{ +//........................................................................ + + using namespace ::com::sun::star; + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::container; + using namespace ::com::sun::star::form::binding; + using namespace ::com::sun::star::xsd; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::form; + + //==================================================================== + //= file-local helpers + //==================================================================== + namespace + { + //-------------------------------------------------------------------- + ::rtl::OUString composeModelElementUIName( const ::rtl::OUString& _rModelName, const ::rtl::OUString& _rElementName ) + { + ::rtl::OUStringBuffer aBuffer; + aBuffer.appendAscii( "[" ); + aBuffer.append( _rModelName ); + aBuffer.appendAscii( "] " ); + aBuffer.append( _rElementName ); + return aBuffer.makeStringAndClear(); + } + } + + //==================================================================== + //= EFormsHelper + //==================================================================== + //-------------------------------------------------------------------- + EFormsHelper::EFormsHelper( ::osl::Mutex& _rMutex, const Reference< XPropertySet >& _rxControlModel, const Reference< frame::XModel >& _rxContextDocument ) + :m_xControlModel( _rxControlModel ) + ,m_aPropertyListeners( _rMutex ) + { + OSL_ENSURE( _rxControlModel.is(), "EFormsHelper::EFormsHelper: invalid control model!" ); + m_xBindableControl = m_xBindableControl.query( _rxControlModel ); + + m_xDocument = m_xDocument.query( _rxContextDocument ); + OSL_ENSURE( m_xDocument.is(), "EFormsHelper::EFormsHelper: invalid document!" ); + + } + + //-------------------------------------------------------------------- + bool EFormsHelper::isEForm( const Reference< frame::XModel >& _rxContextDocument ) + { + try + { + Reference< xforms::XFormsSupplier > xDocument( _rxContextDocument, UNO_QUERY ); + if ( !xDocument.is() ) + return false; + + return xDocument->getXForms().is(); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::isEForm: caught an exception!" ); + } + return false; + } + + //-------------------------------------------------------------------- + bool EFormsHelper::canBindToDataType( sal_Int32 _nDataType ) const SAL_THROW(()) + { + if ( !m_xBindableControl.is() ) + // cannot bind at all + return false; + + // some types cannot be bound, independent from the control type + if ( ( DataTypeClass::hexBinary == _nDataType ) + || ( DataTypeClass::base64Binary == _nDataType ) + || ( DataTypeClass::QName == _nDataType ) + || ( DataTypeClass::NOTATION == _nDataType ) + ) + return false; + + bool bCan = false; + try + { + // classify the control model + sal_Int16 nControlType = FormComponentType::CONTROL; + OSL_VERIFY( m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nControlType ); + + // some lists + sal_Int16 nNumericCompatibleTypes[] = { DataTypeClass::DECIMAL, DataTypeClass::FLOAT, DataTypeClass::DOUBLE, 0 }; + sal_Int16 nDateCompatibleTypes[] = { DataTypeClass::DATE, 0 }; + sal_Int16 nTimeCompatibleTypes[] = { DataTypeClass::TIME, 0 }; + sal_Int16 nCheckboxCompatibleTypes[] = { DataTypeClass::BOOLEAN, DataTypeClass::STRING, DataTypeClass::anyURI, 0 }; + sal_Int16 nRadiobuttonCompatibleTypes[] = { DataTypeClass::STRING, DataTypeClass::anyURI, 0 }; + sal_Int16 nFormattedCompatibleTypes[] = { DataTypeClass::DECIMAL, DataTypeClass::FLOAT, DataTypeClass::DOUBLE, DataTypeClass::DATETIME, DataTypeClass::DATE, DataTypeClass::TIME, 0 }; + + sal_Int16* pCompatibleTypes = NULL; + switch ( nControlType ) + { + case FormComponentType::SPINBUTTON: + case FormComponentType::NUMERICFIELD: + pCompatibleTypes = nNumericCompatibleTypes; + break; + case FormComponentType::DATEFIELD: + pCompatibleTypes = nDateCompatibleTypes; + break; + case FormComponentType::TIMEFIELD: + pCompatibleTypes = nTimeCompatibleTypes; + break; + case FormComponentType::CHECKBOX: + pCompatibleTypes = nCheckboxCompatibleTypes; + break; + case FormComponentType::RADIOBUTTON: + pCompatibleTypes = nRadiobuttonCompatibleTypes; + break; + + case FormComponentType::TEXTFIELD: + { + // both the normal text field, and the formatted field, claim to be a TEXTFIELD + // need to distinguish by service name + Reference< XServiceInfo > xSI( m_xControlModel, UNO_QUERY ); + OSL_ENSURE( xSI.is(), "EFormsHelper::canBindToDataType: a control model which has no service info?" ); + if ( xSI.is() ) + { + if ( xSI->supportsService( SERVICE_COMPONENT_FORMATTEDFIELD ) ) + { + pCompatibleTypes = nFormattedCompatibleTypes; + break; + } + } + // NO break here! + } + case FormComponentType::LISTBOX: + case FormComponentType::COMBOBOX: + // edit fields and list/combo boxes can be bound to anything + bCan = true; + } + + if ( !bCan && pCompatibleTypes ) + { + if ( _nDataType == -1 ) + { + // the control can be bound to at least one type, and exactly this is being asked for + bCan = true; + } + else + { + while ( *pCompatibleTypes && !bCan ) + bCan = ( *pCompatibleTypes++ == _nDataType ); + } + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::canBindToDataType: caught an exception!" ); + } + + return bCan; + } + + //-------------------------------------------------------------------- + bool EFormsHelper::isListEntrySink() const SAL_THROW(()) + { + bool bIs = false; + try + { + Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY ); + bIs = xAsSink.is(); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::isListEntrySink: caught an exception!" ); + } + return bIs; + } + + //-------------------------------------------------------------------- + void EFormsHelper::impl_switchBindingListening_throw( bool _bDoListening, const Reference< XPropertyChangeListener >& _rxListener ) + { + Reference< XPropertySet > xBindingProps; + if ( m_xBindableControl.is() ) + xBindingProps = xBindingProps.query( m_xBindableControl->getValueBinding() ); + if ( !xBindingProps.is() ) + return; + + if ( _bDoListening ) + { + xBindingProps->addPropertyChangeListener( ::rtl::OUString(), _rxListener ); + } + else + { + xBindingProps->removePropertyChangeListener( ::rtl::OUString(), _rxListener ); + } + } + + //-------------------------------------------------------------------- + void EFormsHelper::registerBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener ) + { + if ( !_rxBindingListener.is() ) + return; + impl_toggleBindingPropertyListening_throw( true, _rxBindingListener ); + } + + //-------------------------------------------------------------------- + void EFormsHelper::impl_toggleBindingPropertyListening_throw( bool _bDoListen, const Reference< XPropertyChangeListener >& _rxConcreteListenerOrNull ) + { + if ( !_bDoListen ) + { + ::std::auto_ptr< ::cppu::OInterfaceIteratorHelper > pListenerIterator = m_aPropertyListeners.createIterator(); + while ( pListenerIterator->hasMoreElements() ) + { + PropertyEventTranslation* pTranslator = dynamic_cast< PropertyEventTranslation* >( pListenerIterator->next() ); + OSL_ENSURE( pTranslator, "EFormsHelper::impl_toggleBindingPropertyListening_throw: invalid listener element in my container!" ); + if ( !pTranslator ) + continue; + + Reference< XPropertyChangeListener > xEventSourceTranslator( pTranslator ); + if ( _rxConcreteListenerOrNull.is() ) + { + if ( pTranslator->getDelegator() == _rxConcreteListenerOrNull ) + { + impl_switchBindingListening_throw( false, xEventSourceTranslator ); + m_aPropertyListeners.removeListener( xEventSourceTranslator ); + break; + } + } + else + { + impl_switchBindingListening_throw( false, xEventSourceTranslator ); + } + } + } + else + { + if ( _rxConcreteListenerOrNull.is() ) + { + Reference< XPropertyChangeListener > xEventSourceTranslator( new PropertyEventTranslation( _rxConcreteListenerOrNull, m_xBindableControl ) ); + m_aPropertyListeners.addListener( xEventSourceTranslator ); + impl_switchBindingListening_throw( true, xEventSourceTranslator ); + } + else + { + ::std::auto_ptr< ::cppu::OInterfaceIteratorHelper > pListenerIterator = m_aPropertyListeners.createIterator(); + while ( pListenerIterator->hasMoreElements() ) + { + Reference< XPropertyChangeListener > xListener( pListenerIterator->next(), UNO_QUERY ); + impl_switchBindingListening_throw( true, xListener ); + } + } + } + } + + //-------------------------------------------------------------------- + void EFormsHelper::revokeBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener ) + { + impl_toggleBindingPropertyListening_throw( false, _rxBindingListener ); + } + + //-------------------------------------------------------------------- + void EFormsHelper::getFormModelNames( ::std::vector< ::rtl::OUString >& /* [out] */ _rModelNames ) const SAL_THROW(()) + { + if ( m_xDocument.is() ) + { + try + { + _rModelNames.resize( 0 ); + + Reference< XNameContainer > xForms( m_xDocument->getXForms() ); + OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelNames: invalid forms container!" ); + if ( xForms.is() ) + { + Sequence< ::rtl::OUString > aModelNames = xForms->getElementNames(); + _rModelNames.resize( aModelNames.getLength() ); + ::std::copy( aModelNames.getConstArray(), aModelNames.getConstArray() + aModelNames.getLength(), + _rModelNames.begin() + ); + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getFormModelNames: caught an exception!" ); + } + } + } + + //-------------------------------------------------------------------- + void EFormsHelper::getBindingNames( const ::rtl::OUString& _rModelName, ::std::vector< ::rtl::OUString >& /* [out] */ _rBindingNames ) const SAL_THROW(()) + { + _rBindingNames.resize( 0 ); + try + { + Reference< xforms::XModel > xModel( getFormModelByName( _rModelName ) ); + if ( xModel.is() ) + { + Reference< XNameAccess > xBindings( xModel->getBindings(), UNO_QUERY ); + OSL_ENSURE( xBindings.is(), "EFormsHelper::getBindingNames: invalid bindings container obtained from the model!" ); + if ( xBindings.is() ) + { + Sequence< ::rtl::OUString > aNames = xBindings->getElementNames(); + _rBindingNames.resize( aNames.getLength() ); + ::std::copy( aNames.getConstArray(), aNames.getConstArray() + aNames.getLength(), _rBindingNames.begin() ); + } + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getBindingNames: caught an exception!" ); + } + } + + //-------------------------------------------------------------------- + Reference< xforms::XModel > EFormsHelper::getFormModelByName( const ::rtl::OUString& _rModelName ) const SAL_THROW(()) + { + Reference< xforms::XModel > xReturn; + try + { + Reference< XNameContainer > xForms( m_xDocument->getXForms() ); + OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelByName: invalid forms container!" ); + if ( xForms.is() ) + OSL_VERIFY( xForms->getByName( _rModelName ) >>= xReturn ); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getFormModelByName: caught an exception!" ); + } + return xReturn; + } + + //-------------------------------------------------------------------- + Reference< xforms::XModel > EFormsHelper::getCurrentFormModel() const SAL_THROW(()) + { + Reference< xforms::XModel > xModel; + try + { + Reference< XPropertySet > xBinding( getCurrentBinding() ); + if ( xBinding.is() ) + { + OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_MODEL ) >>= xModel ); + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getCurrentFormModel: caught an exception!" ); + } + return xModel; + } + + //-------------------------------------------------------------------- + ::rtl::OUString EFormsHelper::getCurrentFormModelName() const SAL_THROW(()) + { + ::rtl::OUString sModelName; + try + { + Reference< xforms::XModel > xFormsModel( getCurrentFormModel() ); + if ( xFormsModel.is() ) + sModelName = xFormsModel->getID(); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getCurrentFormModel: caught an exception!" ); + } + return sModelName; + } + + //-------------------------------------------------------------------- + Reference< XPropertySet > EFormsHelper::getCurrentBinding() const SAL_THROW(()) + { + Reference< XPropertySet > xBinding; + + try + { + if ( m_xBindableControl.is() ) + xBinding = xBinding.query( m_xBindableControl->getValueBinding() ); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getCurrentBinding: caught an exception!" ); + } + + return xBinding; + } + + //-------------------------------------------------------------------- + ::rtl::OUString EFormsHelper::getCurrentBindingName() const SAL_THROW(()) + { + ::rtl::OUString sBindingName; + try + { + Reference< XPropertySet > xBinding( getCurrentBinding() ); + if ( xBinding.is() ) + xBinding->getPropertyValue( PROPERTY_BINDING_ID ) >>= sBindingName; + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getCurrentBindingName: caught an exception!" ); + } + return sBindingName; + } + + //-------------------------------------------------------------------- + Reference< XListEntrySource > EFormsHelper::getCurrentListSourceBinding() const SAL_THROW(()) + { + Reference< XListEntrySource > xReturn; + try + { + Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY ); + OSL_ENSURE( xAsSink.is(), "EFormsHelper::getCurrentListSourceBinding: you should have used isListEntrySink before!" ); + if ( xAsSink.is() ) + xReturn = xAsSink->getListEntrySource(); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getCurrentListSourceBinding: caught an exception!" ); + } + return xReturn; + } + + //-------------------------------------------------------------------- + void EFormsHelper::setListSourceBinding( const Reference< XListEntrySource >& _rxListSource ) SAL_THROW(()) + { + try + { + Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY ); + OSL_ENSURE( xAsSink.is(), "EFormsHelper::setListSourceBinding: you should have used isListEntrySink before!" ); + if ( xAsSink.is() ) + xAsSink->setListEntrySource( _rxListSource ); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::setListSourceBinding: caught an exception!" ); + } + } + + //-------------------------------------------------------------------- + void EFormsHelper::setBinding( const Reference< ::com::sun::star::beans::XPropertySet >& _rxBinding ) SAL_THROW(()) + { + if ( !m_xBindableControl.is() ) + return; + + try + { + Reference< XPropertySet > xOldBinding( m_xBindableControl->getValueBinding(), UNO_QUERY ); + + Reference< XValueBinding > xBinding( _rxBinding, UNO_QUERY ); + OSL_ENSURE( xBinding.is() || !_rxBinding.is(), "EFormsHelper::setBinding: invalid binding!" ); + + impl_toggleBindingPropertyListening_throw( false, NULL ); + m_xBindableControl->setValueBinding( xBinding ); + impl_toggleBindingPropertyListening_throw( true, NULL ); + + ::std::set< ::rtl::OUString > aSet; + firePropertyChanges( xOldBinding, _rxBinding, aSet ); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::setBinding: caught an exception!" ); + } + } + + //-------------------------------------------------------------------- + Reference< XPropertySet > EFormsHelper::getOrCreateBindingForModel( const ::rtl::OUString& _rTargetModel, const ::rtl::OUString& _rBindingName ) const SAL_THROW(()) + { + OSL_ENSURE( _rBindingName.getLength(), "EFormsHelper::getOrCreateBindingForModel: invalid binding name!" ); + return implGetOrCreateBinding( _rTargetModel, _rBindingName ); + } + + //-------------------------------------------------------------------- + Reference< XPropertySet > EFormsHelper::implGetOrCreateBinding( const ::rtl::OUString& _rTargetModel, const ::rtl::OUString& _rBindingName ) const SAL_THROW(()) + { + OSL_ENSURE( !( !_rTargetModel.getLength() && _rBindingName .getLength() ), "EFormsHelper::implGetOrCreateBinding: no model, but a binding name?" ); + + Reference< XPropertySet > xBinding; + try + { + ::rtl::OUString sTargetModel( _rTargetModel ); + // determine the model which the binding should belong to + if ( !sTargetModel.getLength() ) + { + ::std::vector< ::rtl::OUString > aModelNames; + getFormModelNames( aModelNames ); + if ( !aModelNames.empty() ) + sTargetModel = *aModelNames.begin(); + OSL_ENSURE( sTargetModel.getLength(), "EFormsHelper::implGetOrCreateBinding: unable to obtain a default model!" ); + } + Reference< xforms::XModel > xModel( getFormModelByName( sTargetModel ) ); + Reference< XNameAccess > xBindingNames( xModel.is() ? xModel->getBindings() : Reference< XSet >(), UNO_QUERY ); + if ( xBindingNames.is() ) + { + // get or create the binding instance + if ( _rBindingName.getLength() ) + { + if ( xBindingNames->hasByName( _rBindingName ) ) + OSL_VERIFY( xBindingNames->getByName( _rBindingName ) >>= xBinding ); + else + { + xBinding = xModel->createBinding( ); + if ( xBinding.is() ) + { + xBinding->setPropertyValue( PROPERTY_BINDING_ID, makeAny( _rBindingName ) ); + xModel->getBindings()->insert( makeAny( xBinding ) ); + } + } + } + else + { + xBinding = xModel->createBinding( ); + if ( xBinding.is() ) + { + // find a nice name for it + String sBaseName( PcrRes( RID_STR_BINDING_UI_NAME ) ); + sBaseName += String::CreateFromAscii( " " ); + String sNewName; + sal_Int32 nNumber = 1; + do + { + sNewName = sBaseName + ::rtl::OUString::valueOf( nNumber++ ); + } + while ( xBindingNames->hasByName( sNewName ) ); + Reference< XNamed > xName( xBinding, UNO_QUERY_THROW ); + xName->setName( sNewName ); + // and insert into the model + xModel->getBindings()->insert( makeAny( xBinding ) ); + } + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + + return xBinding; + } + + //-------------------------------------------------------------------- + namespace + { + //................................................................ + struct PropertyBagInserter : public ::std::unary_function< Property, void > + { + private: + PropertyBag& m_rProperties; + + public: + PropertyBagInserter( PropertyBag& rProperties ) : m_rProperties( rProperties ) { } + + void operator()( const Property& _rProp ) + { + m_rProperties.insert( _rProp ); + } + }; + + //................................................................ + Reference< XPropertySetInfo > collectPropertiesGetInfo( const Reference< XPropertySet >& _rxProps, PropertyBag& _rBag ) + { + Reference< XPropertySetInfo > xInfo; + if ( _rxProps.is() ) + xInfo = _rxProps->getPropertySetInfo(); + if ( xInfo.is() ) + { + Sequence< Property > aProperties = xInfo->getProperties(); + ::std::for_each( aProperties.getConstArray(), aProperties.getConstArray() + aProperties.getLength(), + PropertyBagInserter( _rBag ) + ); + } + return xInfo; + } + } + + //-------------------------------------------------------------------- + ::rtl::OUString EFormsHelper::getModelElementUIName( const EFormsHelper::ModelElementType _eType, const Reference< XPropertySet >& _rxElement ) const SAL_THROW(()) + { + ::rtl::OUString sUIName; + try + { + // determine the model which the element belongs to + Reference< xforms::XFormsUIHelper1 > xHelper; + if ( _rxElement.is() ) + _rxElement->getPropertyValue( PROPERTY_MODEL ) >>= xHelper; + OSL_ENSURE( xHelper.is(), "EFormsHelper::getModelElementUIName: invalid element or model!" ); + if ( xHelper.is() ) + { + ::rtl::OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( _rxElement, sal_True ) : xHelper->getBindingName( _rxElement, sal_True ); + Reference< xforms::XModel > xModel( xHelper, UNO_QUERY_THROW ); + sUIName = composeModelElementUIName( xModel->getID(), sElementName ); + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getModelElementUIName: caught an exception!" ); + } + + return sUIName; + } + + //-------------------------------------------------------------------- + Reference< XPropertySet > EFormsHelper::getModelElementFromUIName( const EFormsHelper::ModelElementType _eType, const ::rtl::OUString& _rUIName ) const SAL_THROW(()) + { + const MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames ); + MapStringToPropertySet::const_iterator pos = rMapUINameToElement.find( _rUIName ); + OSL_ENSURE( pos != rMapUINameToElement.end(), "EFormsHelper::getModelElementFromUIName: didn't find it!" ); + + return ( pos != rMapUINameToElement.end() ) ? pos->second : Reference< XPropertySet >(); + } + + //-------------------------------------------------------------------- + void EFormsHelper::getAllElementUINames( const ModelElementType _eType, ::std::vector< ::rtl::OUString >& /* [out] */ _rElementNames, bool _bPrepentEmptyEntry ) + { + MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames ); + rMapUINameToElement.clear(); + _rElementNames.resize( 0 ); + + if ( _bPrepentEmptyEntry ) + rMapUINameToElement[ ::rtl::OUString() ] = Reference< XPropertySet >(); + + try + { + // obtain the model names + ::std::vector< ::rtl::OUString > aModels; + getFormModelNames( aModels ); + _rElementNames.reserve( aModels.size() * 2 ); // heuristics + + // for every model, obtain the element + for ( ::std::vector< ::rtl::OUString >::const_iterator pModelName = aModels.begin(); + pModelName != aModels.end(); + ++pModelName + ) + { + Reference< xforms::XModel > xModel = getFormModelByName( *pModelName ); + OSL_ENSURE( xModel.is(), "EFormsHelper::getAllElementUINames: inconsistency in the models!" ); + Reference< xforms::XFormsUIHelper1 > xHelper( xModel, UNO_QUERY ); + + Reference< XIndexAccess > xElements; + if ( xModel.is() ) + xElements = xElements.query( ( _eType == Submission ) ? xModel->getSubmissions() : xModel->getBindings() ); + if ( !xElements.is() ) + break; + + sal_Int32 nElementCount = xElements->getCount(); + for ( sal_Int32 i = 0; i < nElementCount; ++i ) + { + Reference< XPropertySet > xElement( xElements->getByIndex( i ), UNO_QUERY ); + OSL_ENSURE( xElement.is(), "EFormsHelper::getAllElementUINames: empty element!" ); + if ( !xElement.is() ) + continue; +#if OSL_DEBUG_LEVEL > 0 + { + Reference< xforms::XModel > xElementsModel; + xElement->getPropertyValue( PROPERTY_MODEL ) >>= xElementsModel; + OSL_ENSURE( xElementsModel == xModel, "EFormsHelper::getAllElementUINames: inconsistency in the model-element relationship!" ); + if ( !( xElementsModel == xModel ) ) + xElement->setPropertyValue( PROPERTY_MODEL, makeAny( xModel ) ); + } +#endif + ::rtl::OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( xElement, sal_True ) : xHelper->getBindingName( xElement, sal_True ); + ::rtl::OUString sUIName = composeModelElementUIName( *pModelName, sElementName ); + + OSL_ENSURE( rMapUINameToElement.find( sUIName ) == rMapUINameToElement.end(), "EFormsHelper::getAllElementUINames: duplicate name!" ); + rMapUINameToElement.insert( MapStringToPropertySet::value_type( sUIName, xElement ) ); + } + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::getAllElementUINames: caught an exception!" ); + } + + _rElementNames.resize( rMapUINameToElement.size() ); + ::std::transform( rMapUINameToElement.begin(), rMapUINameToElement.end(), _rElementNames.begin(), ::std::select1st< MapStringToPropertySet::value_type >() ); + } + + //-------------------------------------------------------------------- + void EFormsHelper::firePropertyChange( const ::rtl::OUString& _rName, const Any& _rOldValue, const Any& _rNewValue ) const + { + if ( m_aPropertyListeners.empty() ) + return; + + if ( _rOldValue == _rNewValue ) + return; + + try + { + PropertyChangeEvent aEvent; + + aEvent.Source = m_xBindableControl.get(); + aEvent.PropertyName = _rName; + aEvent.OldValue = _rOldValue; + aEvent.NewValue = _rNewValue; + + const_cast< EFormsHelper* >( this )->m_aPropertyListeners.notify( aEvent, &XPropertyChangeListener::propertyChange ); + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::firePropertyChange: caught an exception!" ); + } + } + + //-------------------------------------------------------------------- + void EFormsHelper::firePropertyChanges( const Reference< XPropertySet >& _rxOldProps, const Reference< XPropertySet >& _rxNewProps, ::std::set< ::rtl::OUString >& _rFilter ) const + { + if ( m_aPropertyListeners.empty() ) + return; + + try + { + PropertyBag aProperties; + Reference< XPropertySetInfo > xOldInfo = collectPropertiesGetInfo( _rxOldProps, aProperties ); + Reference< XPropertySetInfo > xNewInfo = collectPropertiesGetInfo( _rxNewProps, aProperties ); + + for ( PropertyBag::const_iterator aProp = aProperties.begin(); + aProp != aProperties.end(); + ++aProp + ) + { + if ( _rFilter.find( aProp->Name ) != _rFilter.end() ) + continue; + + Any aOldValue( NULL, aProp->Type ); + if ( xOldInfo.is() && xOldInfo->hasPropertyByName( aProp->Name ) ) + aOldValue = _rxOldProps->getPropertyValue( aProp->Name ); + + Any aNewValue( NULL, aProp->Type ); + if ( xNewInfo.is() && xNewInfo->hasPropertyByName( aProp->Name ) ) + aNewValue = _rxNewProps->getPropertyValue( aProp->Name ); + + firePropertyChange( aProp->Name, aOldValue, aNewValue ); + } + } + catch( const Exception& ) + { + OSL_ENSURE( sal_False, "EFormsHelper::firePropertyChanges: caught an exception!" ); + } + } + +//........................................................................ +} // namespace pcr +//........................................................................ + |