diff options
Diffstat (limited to 'forms/source/component/FormComponent.cxx')
| -rw-r--r-- | forms/source/component/FormComponent.cxx | 2799 |
1 files changed, 2799 insertions, 0 deletions
diff --git a/forms/source/component/FormComponent.cxx b/forms/source/component/FormComponent.cxx new file mode 100644 index 000000000..78213bd3a --- /dev/null +++ b/forms/source/component/FormComponent.cxx @@ -0,0 +1,2799 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#include <componenttools.hxx> +#include <FormComponent.hxx> +#include <strings.hrc> +#include <frm_resource.hxx> +#include <property.hxx> +#include <services.hxx> + +#include <com/sun/star/awt/XTextComponent.hpp> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/form/XForm.hpp> +#include <com/sun/star/form/XLoadable.hpp> +#include <com/sun/star/form/binding/IncompatibleTypesException.hpp> +#include <com/sun/star/io/IOException.hpp> +#include <com/sun/star/io/XMarkableStream.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> +#include <com/sun/star/sdb/XRowSetChangeBroadcaster.hpp> +#include <com/sun/star/sdb/XRowSetSupplier.hpp> +#include <com/sun/star/sdbc/ColumnValue.hpp> +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/sdbc/SQLException.hpp> +#include <com/sun/star/util/VetoException.hpp> +#include <com/sun/star/util/XModifyBroadcaster.hpp> + +#include <comphelper/basicio.hxx> +#include <comphelper/guarding.hxx> +#include <comphelper/property.hxx> +#include <connectivity/dbtools.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <sal/log.hxx> + +#include <algorithm> + +namespace frm +{ +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::form::binding; +using namespace ::com::sun::star::form::validation; +using namespace ::dbtools; +using namespace ::comphelper; + +// FieldChangeNotifier +void ControlModelLock::impl_notifyAll_nothrow() +{ + m_rModel.firePropertyChanges( m_aHandles, m_aOldValues, m_aNewValues, OControlModel::LockAccess() ); +} + +void ControlModelLock::addPropertyNotification( const sal_Int32 _nHandle, const Any& _rOldValue, const Any& _rNewValue ) +{ + assert( m_aHandles.size() == m_aOldValues.size() && m_aOldValues.size() == m_aNewValues.size() ); + + m_aHandles.push_back( _nHandle ); + m_aOldValues.push_back( _rOldValue ); + m_aNewValues.push_back( _rNewValue ); +} + +namespace { + +class FieldChangeNotifier +{ +public: + explicit FieldChangeNotifier(ControlModelLock& _rLock) + : m_rLock( _rLock ) + , m_rModel( dynamic_cast< OBoundControlModel& >( _rLock.getModel() ) ) + { + m_xOldField = m_rModel.getField(); + } + + ~FieldChangeNotifier() + { + Reference< XPropertySet > xNewField( m_rModel.getField() ); + if ( m_xOldField != xNewField ) + m_rLock.addPropertyNotification( PROPERTY_ID_BOUNDFIELD, Any( m_xOldField ), Any( xNewField ) ); + } + +private: + ControlModelLock& m_rLock; + OBoundControlModel& m_rModel; + Reference< XPropertySet > m_xOldField; +}; + +} + +// base class for form layer controls +OControl::OControl( const Reference< XComponentContext >& _rxContext, const OUString& _rAggregateService, const bool _bSetDelegator ) + :OComponentHelper(m_aMutex) + ,m_xContext( _rxContext ) +{ + // Aggregate VCL Control + // Increment the RefCount for aggregates, because the aggregate by itself increments the RefCount in the setDelegator + osl_atomic_increment( &m_refCount ); + { + m_xAggregate.set(_rxContext->getServiceManager()->createInstanceWithContext(_rAggregateService, _rxContext), css::uno::UNO_QUERY); + m_xControl.set(m_xAggregate, css::uno::UNO_QUERY); + } + osl_atomic_decrement( &m_refCount ); + + if ( _bSetDelegator ) + doSetDelegator(); +} + +OControl::~OControl() +{ + doResetDelegator(); +} + +void OControl::doResetDelegator() +{ + if ( m_xAggregate.is() ) + m_xAggregate->setDelegator( nullptr ); +} + +void OControl::doSetDelegator() +{ + osl_atomic_increment( &m_refCount ); + if ( m_xAggregate.is() ) + { // those brackets are important for some compilers, don't remove! + // (they ensure that the temporary object created in the line below + // is destroyed *before* the refcount-decrement) + m_xAggregate->setDelegator( static_cast< XWeak* >( this ) ); + } + osl_atomic_decrement( &m_refCount ); +} + +// UNO Binding +Any SAL_CALL OControl::queryAggregation( const Type& _rType ) +{ + // ask the base class + Any aReturn( OComponentHelper::queryAggregation(_rType) ); + // ask our own interfaces + if (!aReturn.hasValue()) + { + aReturn = OControl_BASE::queryInterface(_rType); + // ask our aggregate + if (!aReturn.hasValue() && m_xAggregate.is()) + aReturn = m_xAggregate->queryAggregation(_rType); + } + + return aReturn; +} + +Sequence<sal_Int8> SAL_CALL OControl::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +Sequence<Type> SAL_CALL OControl::getTypes() +{ + TypeBag aTypes( _getTypes() ); + + Reference< XTypeProvider > xProv; + if ( query_aggregation( m_xAggregate, xProv ) ) + aTypes.addTypes( xProv->getTypes() ); + + return aTypes.getTypes(); +} + +Sequence<Type> OControl::_getTypes() +{ + return TypeBag( OComponentHelper::getTypes(), OControl_BASE::getTypes() ).getTypes(); +} + +// OComponentHelper +void OControl::disposing() +{ + OComponentHelper::disposing(); + + m_aWindowStateGuard.attach( nullptr, nullptr ); + + Reference< XComponent > xComp; + if (query_aggregation(m_xAggregate, xComp)) + xComp->dispose(); +} + +// XServiceInfo +sal_Bool SAL_CALL OControl::supportsService(const OUString& _rsServiceName) +{ + return cppu::supportsService(this, _rsServiceName); +} + +Sequence< OUString > OControl::getAggregateServiceNames() const +{ + Sequence< OUString > aAggServices; + Reference< XServiceInfo > xInfo; + if ( query_aggregation( m_xAggregate, xInfo ) ) + aAggServices = xInfo->getSupportedServiceNames(); + + return aAggServices; +} + +Sequence<OUString> SAL_CALL OControl::getSupportedServiceNames() +{ + // no own supported service names + return getAggregateServiceNames(); +} + +// XEventListener +void SAL_CALL OControl::disposing(const css::lang::EventObject& _rEvent) +{ + Reference< XInterface > xAggAsIface; + query_aggregation(m_xAggregate, xAggAsIface); + + // does the disposing come from the aggregate? + if (xAggAsIface != Reference< XInterface >(_rEvent.Source, UNO_QUERY)) + { // no -> forward it + Reference<css::lang::XEventListener> xListener; + if (query_aggregation(m_xAggregate, xListener)) + xListener->disposing(_rEvent); + } +} + +// XControl +void SAL_CALL OControl::setContext(const Reference< XInterface >& Context) +{ + if (m_xControl.is()) + m_xControl->setContext(Context); +} + +Reference< XInterface > SAL_CALL OControl::getContext() +{ + return m_xControl.is() ? m_xControl->getContext() : Reference< XInterface >(); +} + +void OControl::impl_resetStateGuard_nothrow() +{ + Reference< XWindow2 > xWindow; + Reference< XControlModel > xModel; + try + { + xWindow.set( getPeer(), UNO_QUERY ); + xModel = getModel(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } + m_aWindowStateGuard.attach( xWindow, xModel ); +} + +void SAL_CALL OControl::createPeer(const Reference<XToolkit>& _rxToolkit, const Reference<XWindowPeer>& _rxParent) +{ + if ( m_xControl.is() ) + { + m_xControl->createPeer( _rxToolkit, _rxParent ); + impl_resetStateGuard_nothrow(); + } +} + +Reference<XWindowPeer> SAL_CALL OControl::getPeer() +{ + return m_xControl.is() ? m_xControl->getPeer() : Reference<XWindowPeer>(); +} + +sal_Bool SAL_CALL OControl::setModel(const Reference<XControlModel>& Model) +{ + if ( !m_xControl.is() ) + return false; + + bool bSuccess = m_xControl->setModel( Model ); + impl_resetStateGuard_nothrow(); + return bSuccess; +} + +Reference<XControlModel> SAL_CALL OControl::getModel() +{ + return m_xControl.is() ? m_xControl->getModel() : Reference<XControlModel>(); +} + +Reference<XView> SAL_CALL OControl::getView() +{ + return m_xControl.is() ? m_xControl->getView() : Reference<XView>(); +} + +void SAL_CALL OControl::setDesignMode(sal_Bool bOn) +{ + if (m_xControl.is()) + m_xControl->setDesignMode(bOn); +} + +sal_Bool SAL_CALL OControl::isDesignMode() +{ + return !m_xControl.is() || m_xControl->isDesignMode(); +} + +sal_Bool SAL_CALL OControl::isTransparent() +{ + return !m_xControl.is() || m_xControl->isTransparent(); +} + +OBoundControl::OBoundControl( const Reference< XComponentContext >& _rxContext, + const OUString& _rAggregateService, const bool _bSetDelegator ) + :OControl( _rxContext, _rAggregateService, _bSetDelegator ) + ,m_bLocked(false) +{ +} + +OBoundControl::~OBoundControl() +{ +} + +Sequence< Type> OBoundControl::_getTypes() +{ + return TypeBag( OControl::_getTypes(), OBoundControl_BASE::getTypes() ).getTypes(); +} + +Any SAL_CALL OBoundControl::queryAggregation(const Type& _rType) +{ + Any aReturn; + + // XTypeProvider first - don't ask the OBoundControl_BASE, it would deliver incomplete types + if ( _rType.equals( cppu::UnoType<XTypeProvider>::get() ) ) + aReturn = OControl::queryAggregation( _rType ); + + // ask our own interfaces + // (do this first (except XTypeProvider ) - we want to "overwrite" XPropertiesChangeListener) + if ( !aReturn.hasValue() ) + aReturn = OBoundControl_BASE::queryInterface( _rType ); + + // ask the base class + if ( !aReturn.hasValue() ) + aReturn = OControl::queryAggregation( _rType ); + + return aReturn; +} + +sal_Bool SAL_CALL OBoundControl::getLock() +{ + return m_bLocked; +} + +void SAL_CALL OBoundControl::setLock(sal_Bool _bLock) +{ + if (m_bLocked == bool(_bLock)) + return; + + osl::MutexGuard aGuard(m_aMutex); + _setLock(_bLock); + m_bLocked = _bLock; +} + +void OBoundControl::_setLock(bool _bLock) +{ + // try to set the text component to readonly + Reference< XWindowPeer > xPeer = getPeer(); + Reference< XTextComponent > xText( xPeer, UNO_QUERY ); + + if ( xText.is() ) + xText->setEditable( !_bLock ); + else + { + // disable the window + Reference< XWindow > xComp( xPeer, UNO_QUERY ); + if ( xComp.is() ) + xComp->setEnable( !_bLock ); + } +} + +sal_Bool SAL_CALL OBoundControl::setModel( const Reference< XControlModel >& _rxModel ) +{ + return OControl::setModel( _rxModel ); +} + +void SAL_CALL OBoundControl::disposing(const EventObject& Source) +{ + // just disambiguate + OControl::disposing(Source); +} + +void OBoundControl::disposing() +{ + OControl::disposing(); +} + +// OControlModel +Sequence<sal_Int8> SAL_CALL OControlModel::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +Sequence<Type> SAL_CALL OControlModel::getTypes() +{ + TypeBag aTypes( _getTypes() ); + + Reference< XTypeProvider > xProv; + + if ( query_aggregation( m_xAggregate, xProv ) ) + aTypes.addTypes( xProv->getTypes() ); + + return aTypes.getTypes(); +} + +Sequence<Type> OControlModel::_getTypes() +{ + return TypeBag( OComponentHelper::getTypes(), + OPropertySetAggregationHelper::getTypes(), + OControlModel_BASE::getTypes() + ).getTypes(); +} + +Any SAL_CALL OControlModel::queryAggregation(const Type& _rType) +{ + // base class 1 + Any aReturn(OComponentHelper::queryAggregation(_rType)); + + // base class 2 + if (!aReturn.hasValue()) + { + aReturn = OControlModel_BASE::queryInterface(_rType); + + // our own interfaces + if (!aReturn.hasValue()) + { + aReturn = OPropertySetAggregationHelper::queryInterface(_rType); + // our aggregate + if (!aReturn.hasValue() && m_xAggregate.is() && !_rType.equals(cppu::UnoType<XCloneable>::get())) + aReturn = m_xAggregate->queryAggregation(_rType); + } + } + return aReturn; +} + +void OControlModel::readHelpTextCompatibly(const css::uno::Reference< css::io::XObjectInputStream >& _rxInStream) +{ + OUString sHelpText; + ::comphelper::operator>>( _rxInStream, sHelpText); + try + { + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_HELPTEXT, Any(sHelpText)); + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + SAL_WARN("forms.component", "OControlModel::readHelpTextCompatibly: could not forward the property value to the aggregate!"); + } +} + +void OControlModel::writeHelpTextCompatibly(const css::uno::Reference< css::io::XObjectOutputStream >& _rxOutStream) +{ + OUString sHelpText; + try + { + if (m_xAggregateSet.is()) + m_xAggregateSet->getPropertyValue(PROPERTY_HELPTEXT) >>= sHelpText; + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + SAL_WARN("forms.component", "OControlModel::writeHelpTextCompatibly: could not retrieve the property value from the aggregate!"); + } + ::comphelper::operator<<( _rxOutStream, sHelpText); +} + +OControlModel::OControlModel( + const Reference<XComponentContext>& _rxContext, + const OUString& _rUnoControlModelTypeName, + const OUString& rDefault, const bool _bSetDelegator) + :OComponentHelper(m_aMutex) + ,OPropertySetAggregationHelper(OComponentHelper::rBHelper) + ,m_xContext( _rxContext ) + ,m_lockCount( 0 ) + ,m_aPropertyBagHelper( *this ) + ,m_nTabIndex(FRM_DEFAULT_TABINDEX) + ,m_nClassId(FormComponentType::CONTROL) + ,m_bNativeLook( false ) + ,m_bGenerateVbEvents( false ) + ,m_nControlTypeinMSO(0) // 0 : default value is create from AOO + ,m_nObjIDinMSO(INVALID_OBJ_ID_IN_MSO) + // form controls are usually embedded into documents, not dialogs, and in documents + // the native look is ugly... + // #i37342# +{ + if (_rUnoControlModelTypeName.isEmpty()) // the is a model we have to aggregate + return; + + osl_atomic_increment(&m_refCount); + { + m_xAggregate.set(m_xContext->getServiceManager()->createInstanceWithContext(_rUnoControlModelTypeName, m_xContext), UNO_QUERY); + setAggregation(m_xAggregate); + + if ( m_xAggregateSet.is() ) + { + try + { + if ( !rDefault.isEmpty() ) + m_xAggregateSet->setPropertyValue( PROPERTY_DEFAULTCONTROL, Any( rDefault ) ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OControlModel::OControlModel"); + } + } + } + if (_bSetDelegator) + doSetDelegator(); + + // Refcount is at NULL again + osl_atomic_decrement(&m_refCount); +} + +OControlModel::OControlModel( const OControlModel* _pOriginal, const Reference< XComponentContext>& _rxFactory, const bool _bCloneAggregate, const bool _bSetDelegator ) + :OComponentHelper( m_aMutex ) + ,OPropertySetAggregationHelper( OComponentHelper::rBHelper ) + ,m_xContext( _rxFactory ) + ,m_lockCount( 0 ) + ,m_aPropertyBagHelper( *this ) + ,m_nTabIndex( FRM_DEFAULT_TABINDEX ) + ,m_nClassId( FormComponentType::CONTROL ) +{ + DBG_ASSERT( _pOriginal, "OControlModel::OControlModel: invalid original!" ); + + // copy members + m_aName = _pOriginal->m_aName; + m_aTag = _pOriginal->m_aTag; + m_nTabIndex = _pOriginal->m_nTabIndex; + m_nClassId = _pOriginal->m_nClassId; + m_bNativeLook = _pOriginal->m_bNativeLook; + m_bGenerateVbEvents = _pOriginal->m_bGenerateVbEvents; + m_nControlTypeinMSO = _pOriginal->m_nControlTypeinMSO; + m_nObjIDinMSO = _pOriginal->m_nObjIDinMSO; + + if ( !_bCloneAggregate ) + return; + + // temporarily increment refcount because of temporary references to ourself in the following + osl_atomic_increment( &m_refCount ); + { + // transfer the (only, at the very moment!) ref count + m_xAggregate = createAggregateClone( _pOriginal ); + + // set aggregation (retrieve other direct interfaces of the aggregate) + setAggregation( m_xAggregate ); + } + + // set the delegator, if allowed by our derived class + if ( _bSetDelegator ) + doSetDelegator(); + + // decrement ref count + osl_atomic_decrement( &m_refCount ); +} + +OControlModel::~OControlModel() +{ + // release the aggregate + doResetDelegator( ); +} + +void OControlModel::clonedFrom( const OControlModel* /*_pOriginal*/ ) +{ + // nothing to do in this base class +} + +void OControlModel::doResetDelegator() +{ + if (m_xAggregate.is()) + m_xAggregate->setDelegator(nullptr); +} + +void OControlModel::doSetDelegator() +{ + osl_atomic_increment(&m_refCount); + if (m_xAggregate.is()) + { + m_xAggregate->setDelegator(static_cast<XWeak*>(this)); + } + osl_atomic_decrement(&m_refCount); +} + +// XChild +Reference< XInterface > SAL_CALL OControlModel::getParent() +{ + return m_xParent; +} + +void SAL_CALL OControlModel::setParent(const Reference< XInterface >& _rxParent) +{ + osl::MutexGuard aGuard(m_aMutex); + + Reference<XComponent> xComp(m_xParent, UNO_QUERY); + if (xComp.is()) + xComp->removeEventListener(static_cast<XPropertiesChangeListener*>(this)); + + m_xParent = _rxParent; + xComp.set(m_xParent, css::uno::UNO_QUERY); + + if ( xComp.is() ) + xComp->addEventListener(static_cast<XPropertiesChangeListener*>(this)); +} + +// XNamed +OUString SAL_CALL OControlModel::getName() +{ + OUString aReturn; + try + { + OPropertySetHelper::getFastPropertyValue(PROPERTY_ID_NAME) >>= aReturn; + } + catch (const css::beans::UnknownPropertyException&) + { + css::uno::Any a(cppu::getCaughtException()); + throw WrappedTargetRuntimeException( + "OControlModel::getName", + *this, + a + ); + } + return aReturn; +} + +void SAL_CALL OControlModel::setName(const OUString& _rName) +{ + try + { + setFastPropertyValue(PROPERTY_ID_NAME, Any(_rName)); + } + catch (const css::beans::UnknownPropertyException&) + { + css::uno::Any a(cppu::getCaughtException()); + throw WrappedTargetRuntimeException( + "OControlModel::setName", + *this, + a + ); + } +} + +// XServiceInfo +sal_Bool SAL_CALL OControlModel::supportsService(const OUString& _rServiceName) +{ + return cppu::supportsService(this, _rServiceName); +} + +Sequence< OUString > OControlModel::getAggregateServiceNames() const +{ + Sequence< OUString > aAggServices; + Reference< XServiceInfo > xInfo; + if ( query_aggregation( m_xAggregate, xInfo ) ) + aAggServices = xInfo->getSupportedServiceNames(); + return aAggServices; +} + +Sequence<OUString> SAL_CALL OControlModel::getSupportedServiceNames() +{ + return ::comphelper::concatSequences( + getAggregateServiceNames(), + getSupportedServiceNames_Static() + ); +} + +Sequence< OUString > OControlModel::getSupportedServiceNames_Static() +{ + return { FRM_SUN_FORMCOMPONENT, "com.sun.star.form.FormControlModel" }; +} + +// XEventListener +void SAL_CALL OControlModel::disposing(const css::lang::EventObject& _rSource) +{ + // release the parent + if (_rSource.Source == m_xParent) + { + osl::MutexGuard aGuard(m_aMutex); + m_xParent = nullptr; + } + else + { + Reference<css::lang::XEventListener> xEvtLst; + if (query_aggregation(m_xAggregate, xEvtLst)) + { + osl::MutexGuard aGuard(m_aMutex); + xEvtLst->disposing(_rSource); + } + } +} + +// OComponentHelper +void OControlModel::disposing() +{ + OPropertySetAggregationHelper::disposing(); + + Reference<css::lang::XComponent> xComp; + if (query_aggregation(m_xAggregate, xComp)) + xComp->dispose(); + + setParent(Reference<XFormComponent>()); + + m_aPropertyBagHelper.dispose(); +} + +void OControlModel::writeAggregate( const Reference< XObjectOutputStream >& _rxOutStream ) const +{ + Reference< XPersistObject > xPersist; + if ( query_aggregation( m_xAggregate, xPersist ) ) + xPersist->write( _rxOutStream ); +} + +void OControlModel::readAggregate( const Reference< XObjectInputStream >& _rxInStream ) +{ + Reference< XPersistObject > xPersist; + if ( query_aggregation( m_xAggregate, xPersist ) ) + xPersist->read( _rxInStream ); +} + +void SAL_CALL OControlModel::write(const Reference<css::io::XObjectOutputStream>& _rxOutStream) +{ + osl::MutexGuard aGuard(m_aMutex); + + // 1. writing the UnoControls + Reference<css::io::XMarkableStream> xMark(_rxOutStream, UNO_QUERY); + if ( !xMark.is() ) + { + throw IOException( + ResourceManager::loadString(RID_STR_INVALIDSTREAM), + static_cast< ::cppu::OWeakObject* >( this ) + ); + } + + sal_Int32 nMark = xMark->createMark(); + sal_Int32 nLen = 0; + + _rxOutStream->writeLong(nLen); + + writeAggregate( _rxOutStream ); + + // determining the length + nLen = xMark->offsetToMark(nMark) - 4; + xMark->jumpToMark(nMark); + _rxOutStream->writeLong(nLen); + xMark->jumpToFurthest(); + xMark->deleteMark(nMark); + + // 2. writing a version number + _rxOutStream->writeShort(0x0003); + + // 3. writing the general properties + ::comphelper::operator<<( _rxOutStream, m_aName); + _rxOutStream->writeShort(m_nTabIndex); + ::comphelper::operator<<( _rxOutStream, m_aTag); // 3rd version + + // IMPORTANT NOTE! + // don't write any new members here: this wouldn't be compatible with older versions, as OControlModel + // is a base class which is called in derived classes "read" method. So if you increment the version + // and write new stuff, older office versions will read this in the _derived_ classes, which may result + // in anything from data loss to crash. + // EOIN! +} + +void OControlModel::read(const Reference<css::io::XObjectInputStream>& InStream) +{ + osl::MutexGuard aGuard(m_aMutex); + + Reference<css::io::XMarkableStream> xMark(InStream, UNO_QUERY); + if ( !xMark.is() ) + { + throw IOException( + ResourceManager::loadString(RID_STR_INVALIDSTREAM), + static_cast< ::cppu::OWeakObject* >( this ) + ); + } + + // 1. reading the UnoControls + sal_Int32 nLen = InStream->readLong(); + if (nLen) + { + sal_Int32 nMark = xMark->createMark(); + + try + { + readAggregate( InStream ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } + + xMark->jumpToMark(nMark); + InStream->skipBytes(nLen); + xMark->deleteMark(nMark); + } + + // 2. reading the version number + sal_uInt16 nVersion = InStream->readShort(); + + // 3. reading the general properties + ::comphelper::operator>>( InStream, m_aName); + m_nTabIndex = InStream->readShort(); + + if (nVersion > 0x0002) + ::comphelper::operator>>( InStream, m_aTag); + + // we had a version where we wrote the help text + if (nVersion == 0x0004) + readHelpTextCompatibly(InStream); + + DBG_ASSERT(nVersion < 5, "OControlModel::read : suspicious version number !"); + // 4 was the version where we wrote the help text + // later versions shouldn't exist (see write for a detailed comment) +} + +PropertyState OControlModel::getPropertyStateByHandle( sal_Int32 _nHandle ) +{ + // simply compare the current and the default value + Any aCurrentValue = getPropertyDefaultByHandle( _nHandle ); + Any aDefaultValue; getFastPropertyValue( aDefaultValue, _nHandle ); + + bool bEqual = aCurrentValue == aDefaultValue; + return bEqual ? PropertyState_DEFAULT_VALUE : PropertyState_DIRECT_VALUE; +} + +void OControlModel::setPropertyToDefaultByHandle( sal_Int32 _nHandle) +{ + Any aDefault = getPropertyDefaultByHandle( _nHandle ); + + Any aConvertedValue, aOldValue; + if ( convertFastPropertyValue( aConvertedValue, aOldValue, _nHandle, aDefault ) ) + { + setFastPropertyValue_NoBroadcast( _nHandle, aConvertedValue ); + // TODO: fire the property change + } +} + +Any OControlModel::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const +{ + Any aReturn; + switch ( _nHandle ) + { + case PROPERTY_ID_NAME: + case PROPERTY_ID_TAG: + aReturn <<= OUString(); + break; + case PROPERTY_ID_CLASSID: + aReturn <<= sal_Int16(FormComponentType::CONTROL); + break; + case PROPERTY_ID_TABINDEX: + aReturn <<= sal_Int16(FRM_DEFAULT_TABINDEX); + break; + case PROPERTY_ID_NATIVE_LOOK: + aReturn <<= true; + break; + case PROPERTY_ID_GENERATEVBAEVENTS: + aReturn <<= false; + break; + // added for exporting OCX control + case PROPERTY_ID_CONTROL_TYPE_IN_MSO: + aReturn <<= sal_Int16(0); + break; + case PROPERTY_ID_OBJ_ID_IN_MSO: + aReturn <<= sal_uInt16(INVALID_OBJ_ID_IN_MSO); + break; + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( _nHandle ) ) + m_aPropertyBagHelper.getDynamicPropertyDefaultByHandle( _nHandle, aReturn ); + else + SAL_WARN("forms.component", "OControlModel::convertFastPropertyValue: unknown handle " << _nHandle); + } + return aReturn; +} + +void OControlModel::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const +{ + switch ( _nHandle ) + { + case PROPERTY_ID_NAME: + _rValue <<= m_aName; + break; + case PROPERTY_ID_TAG: + _rValue <<= m_aTag; + break; + case PROPERTY_ID_CLASSID: + _rValue <<= m_nClassId; + break; + case PROPERTY_ID_TABINDEX: + _rValue <<= m_nTabIndex; + break; + case PROPERTY_ID_NATIVE_LOOK: + _rValue <<= m_bNativeLook; + break; + case PROPERTY_ID_GENERATEVBAEVENTS: + _rValue <<= m_bGenerateVbEvents; + break; + // added for exporting OCX control + case PROPERTY_ID_CONTROL_TYPE_IN_MSO: + _rValue <<= m_nControlTypeinMSO; + break; + case PROPERTY_ID_OBJ_ID_IN_MSO: + _rValue <<= m_nObjIDinMSO; + break; + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( _nHandle ) ) + m_aPropertyBagHelper.getDynamicFastPropertyValue( _nHandle, _rValue ); + else + OPropertySetAggregationHelper::getFastPropertyValue( _rValue, _nHandle ); + break; + } +} + +sal_Bool OControlModel::convertFastPropertyValue( + Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue) +{ + bool bModified(false); + switch (_nHandle) + { + case PROPERTY_ID_NAME: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_aName); + break; + case PROPERTY_ID_TAG: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_aTag); + break; + case PROPERTY_ID_TABINDEX: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_nTabIndex); + break; + case PROPERTY_ID_NATIVE_LOOK: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_bNativeLook); + break; + case PROPERTY_ID_GENERATEVBAEVENTS: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_bGenerateVbEvents); + break; + // added for exporting OCX control + case PROPERTY_ID_CONTROL_TYPE_IN_MSO: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_nControlTypeinMSO); + break; + case PROPERTY_ID_OBJ_ID_IN_MSO: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_nObjIDinMSO); + break; + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( _nHandle ) ) + bModified = m_aPropertyBagHelper.convertDynamicFastPropertyValue( _nHandle, _rValue, _rConvertedValue, _rOldValue ); + else + SAL_WARN("forms.component", "OControlModel::convertFastPropertyValue: unknown handle " << _nHandle); + break; + } + return bModified; +} + +void OControlModel::setFastPropertyValue_NoBroadcast(sal_Int32 _nHandle, const Any& _rValue) +{ + switch (_nHandle) + { + case PROPERTY_ID_NAME: + DBG_ASSERT(_rValue.getValueType() == cppu::UnoType<OUString>::get(), + "OControlModel::setFastPropertyValue_NoBroadcast : invalid type" ); + _rValue >>= m_aName; + break; + case PROPERTY_ID_TAG: + DBG_ASSERT(_rValue.getValueType() == cppu::UnoType<OUString>::get(), + "OControlModel::setFastPropertyValue_NoBroadcast : invalid type" ); + _rValue >>= m_aTag; + break; + case PROPERTY_ID_TABINDEX: + DBG_ASSERT(_rValue.getValueType() == cppu::UnoType<sal_Int16>::get(), + "OControlModel::setFastPropertyValue_NoBroadcast : invalid type" ); + _rValue >>= m_nTabIndex; + break; + case PROPERTY_ID_NATIVE_LOOK: + OSL_VERIFY( _rValue >>= m_bNativeLook ); + break; + case PROPERTY_ID_GENERATEVBAEVENTS: + OSL_VERIFY( _rValue >>= m_bGenerateVbEvents ); + break; + // added for exporting OCX control + case PROPERTY_ID_CONTROL_TYPE_IN_MSO: + OSL_VERIFY( _rValue >>= m_nControlTypeinMSO ); + break; + case PROPERTY_ID_OBJ_ID_IN_MSO: + OSL_VERIFY( _rValue >>= m_nObjIDinMSO ); + break; + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( _nHandle ) ) + m_aPropertyBagHelper.setDynamicFastPropertyValue( _nHandle, _rValue ); + else + SAL_WARN("forms.component", "OControlModel::setFastPropertyValue_NoBroadcast: unknown handle " << _nHandle ); + break; + } +} + +void OControlModel::describeFixedProperties( Sequence< Property >& _rProps ) const +{ + _rProps.realloc(7); + css::beans::Property* pProperties = _rProps.getArray(); + *pProperties++ = css::beans::Property(PROPERTY_CLASSID, PROPERTY_ID_CLASSID, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::READONLY | css::beans::PropertyAttribute::TRANSIENT); + *pProperties++ = css::beans::Property(PROPERTY_NAME, PROPERTY_ID_NAME, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND); + *pProperties++ = css::beans::Property(PROPERTY_NATIVE_LOOK, PROPERTY_ID_NATIVE_LOOK, cppu::UnoType<bool>::get(), + css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::TRANSIENT); + *pProperties++ = css::beans::Property(PROPERTY_TAG, PROPERTY_ID_TAG, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND); + *pProperties++ = css::beans::Property(PROPERTY_GENERATEVBAEVENTS, PROPERTY_ID_GENERATEVBAEVENTS, cppu::UnoType<sal_Bool>::get(), css::beans::PropertyAttribute::TRANSIENT); + *pProperties++ = css::beans::Property(PROPERTY_CONTROL_TYPE_IN_MSO, PROPERTY_ID_CONTROL_TYPE_IN_MSO, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::BOUND); + *pProperties++ = css::beans::Property(PROPERTY_OBJ_ID_IN_MSO, PROPERTY_ID_OBJ_ID_IN_MSO, cppu::UnoType<cppu::UnoUnsignedShortType>::get(), css::beans::PropertyAttribute::BOUND); + DBG_ASSERT( pProperties == _rProps.getArray() + _rProps.getLength(), "<...>::describeFixedProperties/getInfoHelper: forgot to adjust the count ?"); +} + +void OControlModel::describeAggregateProperties( Sequence< Property >& /* [out] */ _rAggregateProps ) const +{ + if ( m_xAggregateSet.is() ) + { + Reference< XPropertySetInfo > xPSI( m_xAggregateSet->getPropertySetInfo() ); + if ( xPSI.is() ) + _rAggregateProps = xPSI->getProperties(); + } +} + +::osl::Mutex& OControlModel::getMutex() +{ + return m_aMutex; +} + +void OControlModel::describeFixedAndAggregateProperties( Sequence< Property >& _out_rFixedProperties, Sequence< Property >& _out_rAggregateProperties ) const +{ + describeFixedProperties( _out_rFixedProperties ); + describeAggregateProperties( _out_rAggregateProperties ); +} + +Reference< XMultiPropertySet > OControlModel::getPropertiesInterface() +{ + return Reference< XMultiPropertySet >( *this, UNO_QUERY ); +} + +Reference< XPropertySetInfo> SAL_CALL OControlModel::getPropertySetInfo() +{ + return createPropertySetInfo( getInfoHelper() ); +} + +::cppu::IPropertyArrayHelper& OControlModel::getInfoHelper() +{ + return m_aPropertyBagHelper.getInfoHelper(); +} + +void SAL_CALL OControlModel::addProperty( const OUString& _rName, ::sal_Int16 _nAttributes, const Any& _rInitialValue ) +{ + m_aPropertyBagHelper.addProperty( _rName, _nAttributes, _rInitialValue ); +} + +void SAL_CALL OControlModel::removeProperty( const OUString& _rName ) +{ + m_aPropertyBagHelper.removeProperty( _rName ); +} + +Sequence< PropertyValue > SAL_CALL OControlModel::getPropertyValues() +{ + return m_aPropertyBagHelper.getPropertyValues(); +} + +void SAL_CALL OControlModel::setPropertyValues( const Sequence< PropertyValue >& _rProps ) +{ + m_aPropertyBagHelper.setPropertyValues( _rProps ); +} + +void OControlModel::lockInstance( LockAccess ) +{ + m_aMutex.acquire(); + osl_atomic_increment( &m_lockCount ); +} + +oslInterlockedCount OControlModel::unlockInstance( LockAccess ) +{ + OSL_ENSURE( m_lockCount > 0, "OControlModel::unlockInstance: not locked!" ); + oslInterlockedCount lockCount = osl_atomic_decrement( &m_lockCount ); + m_aMutex.release(); + return lockCount; +} + +void OControlModel::firePropertyChanges( const std::vector< sal_Int32 >& _rHandles, const std::vector< Any >& _rOldValues, + const std::vector< Any >& _rNewValues, LockAccess ) +{ + OPropertySetHelper::fire( + const_cast< std::vector< sal_Int32 >& >( _rHandles ).data(), + _rNewValues.data(), + _rOldValues.data(), + _rHandles.size(), + false + ); +} + +// OBoundControlModel +Any SAL_CALL OBoundControlModel::queryAggregation( const Type& _rType ) +{ + Any aReturn( OControlModel::queryAggregation(_rType) ); + if (!aReturn.hasValue()) + { + aReturn = OBoundControlModel_BASE1::queryInterface(_rType); + + if ( !aReturn.hasValue() && m_bCommitable ) + aReturn = OBoundControlModel_COMMITTING::queryInterface( _rType ); + + if ( !aReturn.hasValue() && m_bSupportsExternalBinding ) + aReturn = OBoundControlModel_BINDING::queryInterface( _rType ); + + if ( !aReturn.hasValue() && m_bSupportsValidation ) + aReturn = OBoundControlModel_VALIDATION::queryInterface( _rType ); + } + return aReturn; +} + +OBoundControlModel::OBoundControlModel( + const Reference< XComponentContext>& _rxFactory, + const OUString& _rUnoControlModelTypeName, const OUString& _rDefault, + const bool _bCommitable, const bool _bSupportExternalBinding, const bool _bSupportsValidation ) + :OControlModel( _rxFactory, _rUnoControlModelTypeName, _rDefault, false ) + ,OPropertyChangeListener( m_aMutex ) + ,m_nValuePropertyAggregateHandle( -1 ) + ,m_nFieldType( DataType::OTHER ) + ,m_bValuePropertyMayBeVoid( false ) + ,m_aResetHelper( *this, m_aMutex ) + ,m_aUpdateListeners(m_aMutex) + ,m_aFormComponentListeners( m_aMutex ) + ,m_bInputRequired( false ) + ,m_bFormListening( false ) + ,m_bLoaded(false) + ,m_bRequired(false) + ,m_bCommitable(_bCommitable) + ,m_bSupportsExternalBinding( _bSupportExternalBinding ) + ,m_bSupportsValidation( _bSupportsValidation ) + ,m_bForwardValueChanges(true) + ,m_bTransferringValue( false ) + ,m_bIsCurrentValueValid( true ) + ,m_bBindingControlsRO( false ) + ,m_bBindingControlsEnable( false ) + ,m_eControlValueChangeInstigator( eOther ) + ,m_aLabelServiceName(FRM_SUN_COMPONENT_FIXEDTEXT) +{ + // start property listening at the aggregate + implInitAggMultiplexer( ); +} + +OBoundControlModel::OBoundControlModel( + const OBoundControlModel* _pOriginal, const Reference< XComponentContext>& _rxFactory ) + :OControlModel( _pOriginal, _rxFactory, true, false ) + ,OPropertyChangeListener( m_aMutex ) + ,m_nValuePropertyAggregateHandle( _pOriginal->m_nValuePropertyAggregateHandle ) + ,m_nFieldType( DataType::OTHER ) + ,m_bValuePropertyMayBeVoid( _pOriginal->m_bValuePropertyMayBeVoid ) + ,m_aResetHelper( *this, m_aMutex ) + ,m_aUpdateListeners( m_aMutex ) + ,m_aFormComponentListeners( m_aMutex ) + ,m_xValidator( _pOriginal->m_xValidator ) + ,m_bInputRequired( false ) + ,m_bFormListening( false ) + ,m_bLoaded( false ) + ,m_bRequired( false ) + ,m_bCommitable( _pOriginal->m_bCommitable ) + ,m_bSupportsExternalBinding( _pOriginal->m_bSupportsExternalBinding ) + ,m_bSupportsValidation( _pOriginal->m_bSupportsValidation ) + ,m_bForwardValueChanges( true ) + ,m_bTransferringValue( false ) + ,m_bIsCurrentValueValid( _pOriginal->m_bIsCurrentValueValid ) + ,m_bBindingControlsRO( false ) + ,m_bBindingControlsEnable( false ) + ,m_eControlValueChangeInstigator( eOther ) +{ + // start property listening at the aggregate + implInitAggMultiplexer( ); + m_aLabelServiceName = _pOriginal->m_aLabelServiceName; + m_sValuePropertyName = _pOriginal->m_sValuePropertyName; + m_nValuePropertyAggregateHandle = _pOriginal->m_nValuePropertyAggregateHandle; + m_bValuePropertyMayBeVoid = _pOriginal->m_bValuePropertyMayBeVoid; + m_aValuePropertyType = _pOriginal->m_aValuePropertyType; + m_aControlSource = _pOriginal->m_aControlSource; + m_bInputRequired = _pOriginal->m_bInputRequired; + // m_xLabelControl, though being a property, is not to be cloned, not even the reference will be transferred. + // (the former should be clear - a clone of the object we're only referencing does not make sense) + // (the second would violate the restriction for label controls that they're part of the + // same form component hierarchy - we ourself are no part, yet, so we can't have a label control) + // start listening for changes at the value property + implInitValuePropertyListening( ); +} + +OBoundControlModel::~OBoundControlModel() +{ + if ( !OComponentHelper::rBHelper.bDisposed ) + { + acquire(); + dispose(); + } + + doResetDelegator( ); + OSL_ENSURE( m_pAggPropMultiplexer, "OBoundControlModel::~OBoundControlModel: what about my property multiplexer?" ); + if ( m_pAggPropMultiplexer ) + { + m_pAggPropMultiplexer->dispose(); + m_pAggPropMultiplexer = nullptr; + } +} + +void OBoundControlModel::clonedFrom( const OControlModel* _pOriginal ) +{ + const OBoundControlModel* pBoundOriginal = static_cast< const OBoundControlModel* >( _pOriginal ); + // the value binding can be handled as if somebody called setValueBinding here + // By definition, bindings can be share between bindables + if ( !(pBoundOriginal && pBoundOriginal->m_xExternalBinding.is()) ) + return; + + try + { + setValueBinding( pBoundOriginal->m_xExternalBinding ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } +} + +void OBoundControlModel::implInitAggMultiplexer( ) +{ + osl_atomic_increment( &m_refCount ); + if ( m_xAggregateSet.is() ) + { + m_pAggPropMultiplexer = new OPropertyChangeMultiplexer( this, m_xAggregateSet, false ); + } + + osl_atomic_decrement( &m_refCount ); + doSetDelegator(); +} + +void OBoundControlModel::implInitValuePropertyListening( ) const +{ + // start listening for changes at the value property + // There are three pre-requisites for this to be done: + // 1. We support external value bindings. In this case, the changes in the control value need to + // be propagated to the external binding immediately when they happen + // 2. We support external validation. In this case, we need to listen for changes in the value + // property, since we need to revalidate then. + // 3. We are not committable. In this case, changes in the control value need to be propagated + // to the database column immediately when they happen. + if ( m_bSupportsExternalBinding || m_bSupportsValidation || !m_bCommitable ) + { + OSL_ENSURE( m_pAggPropMultiplexer, "OBoundControlModel::implInitValuePropertyListening: no multiplexer!" ); + if ( m_pAggPropMultiplexer && !m_sValuePropertyName.isEmpty() ) + m_pAggPropMultiplexer->addProperty( m_sValuePropertyName ); + } +} + +void OBoundControlModel::initOwnValueProperty( const OUString& i_rValuePropertyName ) +{ + OSL_PRECOND( m_sValuePropertyName.isEmpty() && -1 == m_nValuePropertyAggregateHandle, + "OBoundControlModel::initOwnValueProperty: value property is already initialized!" ); + OSL_ENSURE( !i_rValuePropertyName.isEmpty(), "OBoundControlModel::initOwnValueProperty: invalid property name!" ); + m_sValuePropertyName = i_rValuePropertyName; +} + +void OBoundControlModel::initValueProperty( const OUString& _rValuePropertyName, sal_Int32 _nValuePropertyExternalHandle ) +{ + OSL_PRECOND( m_sValuePropertyName.isEmpty() && -1 == m_nValuePropertyAggregateHandle, + "OBoundControlModel::initValueProperty: value property is already initialized!" ); + OSL_ENSURE( !_rValuePropertyName.isEmpty(), "OBoundControlModel::initValueProperty: invalid property name!" ); + OSL_ENSURE( _nValuePropertyExternalHandle != -1, "OBoundControlModel::initValueProperty: invalid property handle!" ); + + m_sValuePropertyName = _rValuePropertyName; + m_nValuePropertyAggregateHandle = getOriginalHandle( _nValuePropertyExternalHandle ); + OSL_ENSURE( m_nValuePropertyAggregateHandle != -1, "OBoundControlModel::initValueProperty: unable to find the original handle!" ); + + if ( m_nValuePropertyAggregateHandle != -1 ) + { + Reference< XPropertySetInfo > xPropInfo( m_xAggregateSet->getPropertySetInfo(), UNO_SET_THROW ); + Property aValuePropDesc = xPropInfo->getPropertyByName( m_sValuePropertyName ); + m_aValuePropertyType = aValuePropDesc.Type; + m_bValuePropertyMayBeVoid = ( aValuePropDesc.Attributes & PropertyAttribute::MAYBEVOID ) != 0; + } + + // start listening for changes at the value property + implInitValuePropertyListening( ); +} + +void OBoundControlModel::suspendValueListening( ) +{ + OSL_PRECOND( !m_sValuePropertyName.isEmpty(), "OBoundControlModel::suspendValueListening: don't have a value property!" ); + OSL_PRECOND( m_pAggPropMultiplexer, "OBoundControlModel::suspendValueListening: I *am* not listening!" ); + + if ( m_pAggPropMultiplexer ) + m_pAggPropMultiplexer->lock(); +} + +void OBoundControlModel::resumeValueListening( ) +{ + OSL_PRECOND( !m_sValuePropertyName.isEmpty(), "OBoundControlModel::resumeValueListening: don't have a value property!" ); + OSL_PRECOND( m_pAggPropMultiplexer, "OBoundControlModel::resumeValueListening: I *am* not listening at all!" ); + OSL_PRECOND( !m_pAggPropMultiplexer || m_pAggPropMultiplexer->locked(), "OBoundControlModel::resumeValueListening: listening not suspended currently!" ); + if ( m_pAggPropMultiplexer ) + m_pAggPropMultiplexer->unlock(); +} + +Sequence< Type > OBoundControlModel::_getTypes() +{ + TypeBag aTypes( + OControlModel::_getTypes(), + OBoundControlModel_BASE1::getTypes() + ); + + if ( m_bCommitable ) + aTypes.addTypes( OBoundControlModel_COMMITTING::getTypes() ); + + if ( m_bSupportsExternalBinding ) + aTypes.addTypes( OBoundControlModel_BINDING::getTypes() ); + + if ( m_bSupportsValidation ) + aTypes.addTypes( OBoundControlModel_VALIDATION::getTypes() ); + return aTypes.getTypes(); +} + +// OComponentHelper +void OBoundControlModel::disposing() +{ + OControlModel::disposing(); + + osl::MutexGuard aGuard(m_aMutex); + + if ( m_pAggPropMultiplexer ) + m_pAggPropMultiplexer->dispose(); + + // notify all our listeners + css::lang::EventObject aEvt( static_cast< XWeak* >( this ) ); + m_aUpdateListeners.disposeAndClear( aEvt ); + m_aResetHelper.disposing(); + + // disconnect from our database column + // TODO: could we replace the following 5 lines with a call to impl_disconnectDatabaseColumn_noNotify? + // The only more thing which it does is calling onDisconnectedDbColumn - could this + // cause trouble? At least when we continue to call OControlModel::disposing before, it *may*. + if ( hasField() ) + { + getField()->removePropertyChangeListener( PROPERTY_VALUE, this ); + resetField(); + } + + m_xCursor = nullptr; + Reference< XComponent > xComp( m_xLabelControl, UNO_QUERY ); + if ( xComp.is() ) + xComp->removeEventListener(static_cast< XEventListener* >( static_cast< XPropertyChangeListener* >( this ) ) ); + // disconnect from our external value binding + if ( hasExternalValueBinding() ) + disconnectExternalValueBinding(); + // ditto for the validator + if ( hasValidator() ) + disconnectValidator( ); +} + +void OBoundControlModel::onValuePropertyChange( ControlModelLock& i_rControLock ) +{ + if ( hasExternalValueBinding() ) + { + // the control value changed, while we have an external value binding + // -> forward the value to it + if ( m_eControlValueChangeInstigator != eExternalBinding ) + transferControlValueToExternal( i_rControLock ); + } + + else if ( !m_bCommitable && m_xColumnUpdate.is() ) + { + // the control value changed, while we are bound to a database column, + // but not committable (which means changes in the control have to be reflected to + // the underlying database column immediately) + // -> forward the value to the database column + if ( m_eControlValueChangeInstigator != eDbColumnBinding ) + commitControlValueToDbColumn( false ); + } + + // validate the new value + if ( m_bSupportsValidation ) + recheckValidity( true ); +} + +void OBoundControlModel::_propertyChanged( const PropertyChangeEvent& _rEvt ) +{ + ControlModelLock aLock( *this ); + OSL_ENSURE( _rEvt.PropertyName == m_sValuePropertyName, + "OBoundControlModel::_propertyChanged: where did this come from (1)?" ); + OSL_ENSURE( m_pAggPropMultiplexer && !m_pAggPropMultiplexer->locked(), + "OBoundControlModel::_propertyChanged: where did this come from (2)?" ); + if ( _rEvt.PropertyName == m_sValuePropertyName ) + { + onValuePropertyChange( aLock ); + } +} + +void OBoundControlModel::startAggregatePropertyListening( const OUString& _rPropertyName ) +{ + OSL_PRECOND( m_pAggPropMultiplexer, "OBoundControlModel::startAggregatePropertyListening: no multiplexer!" ); + OSL_ENSURE( !_rPropertyName.isEmpty(), "OBoundControlModel::startAggregatePropertyListening: invalid property name!" ); + if ( m_pAggPropMultiplexer && !_rPropertyName.isEmpty() ) + { + m_pAggPropMultiplexer->addProperty( _rPropertyName ); + } +} + +void OBoundControlModel::doFormListening( const bool _bStart ) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::doFormListening: external value binding should overrule the database binding!" ); + if ( isFormListening() == _bStart ) + return; + if ( m_xAmbientForm.is() ) + _bStart ? m_xAmbientForm->addLoadListener( this ) : m_xAmbientForm->removeLoadListener( this ); + Reference< XLoadable > xParentLoadable( getParent(), UNO_QUERY ); + if ( getParent().is() && !xParentLoadable.is() ) + { + // if our parent does not directly support the XLoadable interface, then it might support the + // XRowSetSupplier/XRowSetChangeBroadcaster interfaces. In this case we have to listen for changes + // broadcasted by the latter. + Reference< XRowSetChangeBroadcaster > xRowSetBroadcaster( getParent(), UNO_QUERY ); + if ( xRowSetBroadcaster.is() ) + _bStart ? xRowSetBroadcaster->addRowSetChangeListener( this ) : xRowSetBroadcaster->removeRowSetChangeListener( this ); + } + + m_bFormListening = _bStart && m_xAmbientForm.is(); +} + +// XChild +void SAL_CALL OBoundControlModel::setParent(const Reference<XInterface>& _rxParent) +{ + ControlModelLock aLock( *this ); + FieldChangeNotifier aBoundFieldNotifier( aLock ); + if ( getParent() == _rxParent ) + return; + // disconnect from database column (which is controlled by parent, directly or indirectly) + if ( hasField() ) + impl_disconnectDatabaseColumn_noNotify(); + // log off old listeners + if ( isFormListening() ) + doFormListening( false ); + // actually set the new parent + OControlModel::setParent( _rxParent ); + // a new parent means a new ambient form + impl_determineAmbientForm_nothrow(); + if ( !hasExternalValueBinding() ) + { + // log on new listeners + doFormListening( true ); + // re-connect to database column of the new parent + if ( m_xAmbientForm.is() && m_xAmbientForm->isLoaded() ) + impl_connectDatabaseColumn_noNotify( false ); + } +} + +// XEventListener +void SAL_CALL OBoundControlModel::disposing(const css::lang::EventObject& _rEvent) +{ + ControlModelLock aLock( *this ); + if ( _rEvent.Source == getField() ) + { + resetField(); + } + + else if ( _rEvent.Source == m_xLabelControl ) + { + Reference<XPropertySet> xOldValue = m_xLabelControl; + m_xLabelControl = nullptr; + // fire a propertyChanged (when we leave aLock's scope) + aLock.addPropertyNotification( PROPERTY_ID_CONTROLLABEL, Any( xOldValue ), Any( m_xLabelControl ) ); + } + + else if ( _rEvent.Source == m_xExternalBinding ) + { // *first* check for the external binding + disconnectExternalValueBinding( ); + } + + else if ( _rEvent.Source == m_xValidator ) + { // *then* check for the validator. Reason is that bindings may also act as validator at the same + // time, in this case, the validator is automatically revoked when the binding is revoked + disconnectValidator( ); + } + + else + OControlModel::disposing(_rEvent); +} + +// XServiceInfo +css::uno::Sequence<OUString> SAL_CALL OBoundControlModel::getSupportedServiceNames() +{ + return ::comphelper::combineSequences( + getAggregateServiceNames(), + getSupportedServiceNames_Static() + ); +} + +Sequence< OUString > OBoundControlModel::getSupportedServiceNames_Static() +{ + Sequence<OUString> aOwnServiceNames { "com.sun.star.form.DataAwareControlModel" }; + return ::comphelper::concatSequences( + OControlModel::getSupportedServiceNames_Static(), + aOwnServiceNames + ); +} + +// XPersist +void SAL_CALL OBoundControlModel::write( const Reference<css::io::XObjectOutputStream>& _rxOutStream ) +{ + OControlModel::write(_rxOutStream); + osl::MutexGuard aGuard(m_aMutex); + // Version + _rxOutStream->writeShort(0x0002); + // Controlsource + ::comphelper::operator<<( _rxOutStream, m_aControlSource); + // !!! IMPORTANT NOTE !!! + // don't write any new members here: this wouldn't be compatible with older versions, as OBoundControlModel + // is a base class which is called in derived classes "read" method. So if you increment the version + // and write new stuff, older office versions will read this in the _derived_ classes, which may result + // in anything from data loss to crash. + // (use writeCommonProperties instead, this is called in derived classes write-method) + // !!! EOIN !!! +} + +void OBoundControlModel::defaultCommonProperties() +{ + Reference<css::lang::XComponent> xComp(m_xLabelControl, UNO_QUERY); + if (xComp.is()) + xComp->removeEventListener(static_cast<css::lang::XEventListener*>(static_cast<XPropertyChangeListener*>(this))); + m_xLabelControl = nullptr; +} + +void OBoundControlModel::readCommonProperties(const Reference<css::io::XObjectInputStream>& _rxInStream) +{ + sal_Int32 nLen = _rxInStream->readLong(); + Reference<css::io::XMarkableStream> xMark(_rxInStream, UNO_QUERY); + DBG_ASSERT(xMark.is(), "OBoundControlModel::readCommonProperties : can only work with markable streams !"); + sal_Int32 nMark = xMark->createMark(); + // read the reference to the label control + Reference<css::io::XPersistObject> xPersist; + sal_Int32 nUsedFlag; + nUsedFlag = _rxInStream->readLong(); + if (nUsedFlag) + xPersist = _rxInStream->readObject(); + m_xLabelControl.set(xPersist, css::uno::UNO_QUERY); + Reference< XComponent > xComp( m_xLabelControl, UNO_QUERY ); + if (xComp.is()) + xComp->addEventListener(static_cast<css::lang::XEventListener*>(static_cast<XPropertyChangeListener*>(this))); + // read any other new common properties here + // skip the remaining bytes + xMark->jumpToMark(nMark); + _rxInStream->skipBytes(nLen); + xMark->deleteMark(nMark); +} + +void OBoundControlModel::writeCommonProperties(const Reference<css::io::XObjectOutputStream>& _rxOutStream) +{ + Reference<css::io::XMarkableStream> xMark(_rxOutStream, UNO_QUERY); + DBG_ASSERT(xMark.is(), "OBoundControlModel::writeCommonProperties : can only work with markable streams !"); + sal_Int32 nMark = xMark->createMark(); + // a placeholder where we will write the overall length (later in this method) + sal_Int32 nLen = 0; + _rxOutStream->writeLong(nLen); + // write the reference to the label control + Reference<css::io::XPersistObject> xPersist(m_xLabelControl, UNO_QUERY); + sal_Int32 nUsedFlag = 0; + if (xPersist.is()) + nUsedFlag = 1; + _rxOutStream->writeLong(nUsedFlag); + if (xPersist.is()) + _rxOutStream->writeObject(xPersist); + // write any other new common properties here + // write the correct length at the beginning of the block + nLen = xMark->offsetToMark(nMark) - sizeof(nLen); + xMark->jumpToMark(nMark); + _rxOutStream->writeLong(nLen); + xMark->jumpToFurthest(); + xMark->deleteMark(nMark); +} + +void SAL_CALL OBoundControlModel::read( const Reference< css::io::XObjectInputStream >& _rxInStream ) +{ + OControlModel::read(_rxInStream); + osl::MutexGuard aGuard(m_aMutex); + _rxInStream->readShort(); // version; + ::comphelper::operator>>( _rxInStream, m_aControlSource); +} + +void OBoundControlModel::getFastPropertyValue(Any& rValue, sal_Int32 nHandle) const +{ + switch (nHandle) + { + case PROPERTY_ID_INPUT_REQUIRED: + rValue <<= m_bInputRequired; + break; + case PROPERTY_ID_CONTROLSOURCEPROPERTY: + rValue <<= m_sValuePropertyName; + break; + case PROPERTY_ID_CONTROLSOURCE: + rValue <<= m_aControlSource; + break; + case PROPERTY_ID_BOUNDFIELD: + rValue <<= getField(); + break; + case PROPERTY_ID_CONTROLLABEL: + if (!m_xLabelControl.is()) + rValue.clear(); + else + rValue <<= m_xLabelControl; + break; + default: + OControlModel::getFastPropertyValue(rValue, nHandle); + } +} + +sal_Bool OBoundControlModel::convertFastPropertyValue( + Any& _rConvertedValue, Any& _rOldValue, + sal_Int32 _nHandle, + const Any& _rValue) +{ + bool bModified(false); + switch (_nHandle) + { + case PROPERTY_ID_INPUT_REQUIRED: + bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, m_bInputRequired ); + break; + case PROPERTY_ID_CONTROLSOURCE: + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_aControlSource); + break; + case PROPERTY_ID_BOUNDFIELD: + SAL_WARN("forms.component", "OBoundControlModel::convertFastPropertyValue: BoundField should be a read-only property !" ); + throw css::lang::IllegalArgumentException(); + case PROPERTY_ID_CONTROLLABEL: + if (!_rValue.hasValue()) + { // property set to void + _rConvertedValue = Any(); + getFastPropertyValue(_rOldValue, _nHandle); + bModified = m_xLabelControl.is(); + } + + else + { + bModified = tryPropertyValue(_rConvertedValue, _rOldValue, _rValue, m_xLabelControl); + if (!m_xLabelControl.is()) + // an empty interface is interpreted as VOID + _rOldValue.clear(); + } + + break; + default: + bModified = OControlModel::convertFastPropertyValue(_rConvertedValue, _rOldValue, _nHandle, _rValue); + } + return bModified; +} + +Any OBoundControlModel::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const +{ + Any aDefault; + switch ( _nHandle ) + { + case PROPERTY_ID_INPUT_REQUIRED: + aDefault <<= false; + break; + case PROPERTY_ID_CONTROLSOURCE: + aDefault <<= OUString(); + break; + case PROPERTY_ID_CONTROLLABEL: + aDefault <<= Reference< XPropertySet >(); + break; + } + return aDefault; +} + +void OBoundControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) +{ + switch (nHandle) + { + case PROPERTY_ID_INPUT_REQUIRED: + OSL_VERIFY( rValue >>= m_bInputRequired ); + break; + case PROPERTY_ID_CONTROLSOURCE: + OSL_VERIFY( rValue >>= m_aControlSource ); + break; + case PROPERTY_ID_BOUNDFIELD: + SAL_WARN("forms.component", "OBoundControlModel::setFastPropertyValue_NoBroadcast : BoundField should be a read-only property !"); + throw css::lang::IllegalArgumentException(); + case PROPERTY_ID_CONTROLLABEL: + { + if ( rValue.hasValue() && ( rValue.getValueTypeClass() != TypeClass_INTERFACE ) ) + throw css::lang::IllegalArgumentException(); + Reference< XInterface > xNewValue( rValue, UNO_QUERY ); + if ( !xNewValue.is() ) + { // set property to "void" + Reference< XComponent > xComp( m_xLabelControl, UNO_QUERY ); + if ( xComp.is() ) + xComp->removeEventListener( static_cast< XPropertyChangeListener* >( this ) ); + m_xLabelControl = nullptr; + break; + } + + Reference< XControlModel > xAsModel ( xNewValue, UNO_QUERY ); + Reference< XServiceInfo > xAsServiceInfo ( xAsModel, UNO_QUERY ); + Reference< XPropertySet > xAsPropSet ( xAsServiceInfo, UNO_QUERY ); + Reference< XChild > xAsChild ( xAsPropSet, UNO_QUERY ); + if ( !xAsChild.is() || !xAsServiceInfo->supportsService( m_aLabelServiceName ) ) + { + throw css::lang::IllegalArgumentException(); + } + + // Check if we and the given model have a common ancestor (up to the forms collection) + Reference<XChild> xCont(this); + Reference< XInterface > xMyTopLevel = xCont->getParent(); + while (xMyTopLevel.is()) + { + Reference<XForm> xAsForm(xMyTopLevel, UNO_QUERY); + if (!xAsForm.is()) + // found my root + break; + Reference<XChild> xLoopAsChild(xMyTopLevel, UNO_QUERY); + xMyTopLevel = xLoopAsChild.is() ? xLoopAsChild->getParent() : Reference< XInterface >(); + } + + Reference< XInterface > xNewTopLevel = xAsChild->getParent(); + while (xNewTopLevel.is()) + { + Reference<XForm> xAsForm(xNewTopLevel, UNO_QUERY); + if (!xAsForm.is()) + break; + Reference<XChild> xLoopAsChild(xNewTopLevel, UNO_QUERY); + xNewTopLevel = xLoopAsChild.is() ? xLoopAsChild->getParent() : Reference< XInterface >(); + } + + if (xNewTopLevel != xMyTopLevel) + { + // the both objects don't belong to the same forms collection -> not acceptable + throw css::lang::IllegalArgumentException(); + } + + m_xLabelControl = xAsPropSet; + Reference<css::lang::XComponent> xComp(m_xLabelControl, UNO_QUERY); + if (xComp.is()) + xComp->addEventListener(static_cast<css::lang::XEventListener*>(static_cast<XPropertyChangeListener*>(this))); + } + + break; + default: + OControlModel::setFastPropertyValue_NoBroadcast(nHandle, rValue ); + } +} + +// XPropertyChangeListener +void SAL_CALL OBoundControlModel::propertyChange( const PropertyChangeEvent& evt ) +{ + // if the DBColumn value changed, transfer it to the control + if ( evt.PropertyName == PROPERTY_VALUE ) + { + OSL_ENSURE( evt.Source == getField(), "OBoundControlModel::propertyChange: value changes from components other than our database column?" ); + osl::MutexGuard aGuard(m_aMutex); + if ( m_bForwardValueChanges && m_xColumn.is() ) + transferDbValueToControl(); + } + + else + { + OSL_ENSURE( evt.Source == m_xExternalBinding, "OBoundControlModel::propertyChange: where did this come from?" ); + // our binding has properties which can control properties of ourself + OUString sBindingControlledProperty; + bool bForwardToLabelControl = false; + if ( evt.PropertyName == PROPERTY_READONLY ) + { + sBindingControlledProperty = PROPERTY_READONLY; + } + + else if ( evt.PropertyName == PROPERTY_RELEVANT ) + { + sBindingControlledProperty = PROPERTY_ENABLED; + bForwardToLabelControl = true; + } + + else + return; + try + { + setPropertyValue( sBindingControlledProperty, evt.NewValue ); + if ( bForwardToLabelControl && m_xLabelControl.is() ) + m_xLabelControl->setPropertyValue( sBindingControlledProperty, evt.NewValue ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + SAL_WARN("forms.component", "OBoundControlModel::propertyChange: could not adjust my binding-controlled property!"); + } + + } +} + +void SAL_CALL OBoundControlModel::onRowSetChanged( const EventObject& /*i_Event*/ ) +{ + ControlModelLock aLock( *this ); + FieldChangeNotifier aBoundFieldNotifier( aLock ); + // disconnect from database column (which is controlled by parent, directly or indirectly) + if ( hasField() ) + impl_disconnectDatabaseColumn_noNotify(); + // log off old listeners + if ( isFormListening() ) + doFormListening( false ); + // determine the new ambient form + impl_determineAmbientForm_nothrow(); + // log on new listeners + doFormListening( true ); + // re-connect to database column if needed and possible + if ( m_xAmbientForm.is() && m_xAmbientForm->isLoaded() ) + impl_connectDatabaseColumn_noNotify( false ); +} + +// XBoundComponent +void SAL_CALL OBoundControlModel::addUpdateListener(const Reference<XUpdateListener>& _rxListener) +{ + m_aUpdateListeners.addInterface(_rxListener); +} + +void SAL_CALL OBoundControlModel::removeUpdateListener(const Reference< XUpdateListener>& _rxListener) +{ + m_aUpdateListeners.removeInterface(_rxListener); +} + +sal_Bool SAL_CALL OBoundControlModel::commit() +{ + ControlModelLock aLock( *this ); + OSL_PRECOND( m_bCommitable, "OBoundControlModel::commit: invalid call (I'm not committable!) " ); + if ( hasExternalValueBinding() ) + { + // in most cases, no action is required: For most derivees, we know the value property of + // our control (see initValueProperty), and when an external binding is active, we + // instantly forward all changes in this property to the external binding. + if ( m_sValuePropertyName.isEmpty() ) + // but for those derivees which did not use this feature, we need an + // explicit transfer + transferControlValueToExternal( aLock ); + return true; + } + + OSL_ENSURE( !hasExternalValueBinding(), "OBoundControlModel::commit: control flow broken!" ); + // we reach this only if we're not working with an external binding + if ( !hasField() ) + return true; + ::comphelper::OInterfaceIteratorHelper3 aIter( m_aUpdateListeners ); + EventObject aEvent; + aEvent.Source = static_cast< XWeak* >( this ); + bool bSuccess = true; + aLock.release(); + // UNSAFE > + while (aIter.hasMoreElements() && bSuccess) + bSuccess = aIter.next()->approveUpdate( aEvent ); + // < UNSAFE + aLock.acquire(); + if ( bSuccess ) + { + try + { + if ( m_xColumnUpdate.is() ) + bSuccess = commitControlValueToDbColumn( false ); + } + + catch(const Exception&) + { + bSuccess = false; + } + + } + + if ( bSuccess ) + { + aLock.release(); + m_aUpdateListeners.notifyEach( &XUpdateListener::updated, aEvent ); + } + return bSuccess; +} + +void OBoundControlModel::resetField() +{ + m_xColumnUpdate.clear(); + m_xColumn.clear(); + m_xField.clear(); + m_nFieldType = DataType::OTHER; +} + +void OBoundControlModel::connectToField(const Reference<XRowSet>& rForm) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::connectToField: invalid call (have an external binding)!" ); + // if there's a connection to the database + if (!(rForm.is() && getConnection(rForm).is())) + return; + + // determine field and PropertyChangeListener + m_xCursor = rForm; + Reference<XPropertySet> xFieldCandidate; + if (m_xCursor.is()) + { + Reference<XColumnsSupplier> xColumnsSupplier(m_xCursor, UNO_QUERY); + DBG_ASSERT(xColumnsSupplier.is(), "OBoundControlModel::connectToField : the row set should support the css::sdb::ResultSet service !"); + if (xColumnsSupplier.is()) + { + Reference<XNameAccess> xColumns = xColumnsSupplier->getColumns(); + if (xColumns.is() && xColumns->hasByName(m_aControlSource)) + { + OSL_VERIFY( xColumns->getByName(m_aControlSource) >>= xFieldCandidate ); + } + + } + + } + + try + { + sal_Int32 nFieldType = DataType::OTHER; + if ( xFieldCandidate.is() ) + { + xFieldCandidate->getPropertyValue( PROPERTY_FIELDTYPE ) >>= nFieldType; + if ( approveDbColumnType( nFieldType ) ) + impl_setField_noNotify( xFieldCandidate ); + } + + else + impl_setField_noNotify( nullptr ); + if ( m_xField.is() ) + { + if ( m_xField->getPropertySetInfo()->hasPropertyByName( PROPERTY_VALUE ) ) + { + m_nFieldType = nFieldType; + // listen to changing values + m_xField->addPropertyChangeListener( PROPERTY_VALUE, this ); + m_xColumnUpdate.set( m_xField, UNO_QUERY ); + m_xColumn.set( m_xField, UNO_QUERY ); + sal_Int32 nNullableFlag = ColumnValue::NO_NULLS; + m_xField->getPropertyValue(PROPERTY_ISNULLABLE) >>= nNullableFlag; + m_bRequired = (ColumnValue::NO_NULLS == nNullableFlag); + // we're optimistic: in case of ColumnValue_NULLABLE_UNKNOWN we assume nullability... + } + else + { + SAL_WARN("forms.component", "OBoundControlModel::connectToField: property " << PROPERTY_VALUE << " not supported!"); + impl_setField_noNotify( nullptr ); + } + + } + + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + resetField(); + } +} + +void OBoundControlModel::initFromField( const Reference< XRowSet >& _rxRowSet ) +{ + // but only if the rowset is positioned on a valid record + if ( !(hasField() && _rxRowSet.is()) ) + return; + + bool shouldTransfer(!_rxRowSet->isBeforeFirst() && !_rxRowSet->isAfterLast()); + if (!shouldTransfer) + { + const Reference< XPropertySet > xPS(_rxRowSet, UNO_QUERY); + if (xPS.is()) + { + assert(!shouldTransfer); + xPS->getPropertyValue("IsNew") >>= shouldTransfer; + } + } + if ( shouldTransfer ) + transferDbValueToControl(); + else + // reset the field if the row set is empty + // #i30661# + resetNoBroadcast(); +} + +bool OBoundControlModel::approveDbColumnType(sal_Int32 _nColumnType) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::approveDbColumnType: invalid call (have an external binding)!" ); + if ((_nColumnType == DataType::BINARY) || (_nColumnType == DataType::VARBINARY) + || (_nColumnType == DataType::LONGVARBINARY) || (_nColumnType == DataType::OTHER) + || (_nColumnType == DataType::OBJECT) || (_nColumnType == DataType::DISTINCT) + || (_nColumnType == DataType::STRUCT) || (_nColumnType == DataType::ARRAY) + || (_nColumnType == DataType::BLOB) /*|| (_nColumnType == DataType::CLOB)*/ + || (_nColumnType == DataType::REF) || (_nColumnType == DataType::SQLNULL)) + return false; + return true; +} + +void OBoundControlModel::impl_determineAmbientForm_nothrow() +{ + Reference< XInterface > xParent( getParent() ); + m_xAmbientForm.set( xParent, UNO_QUERY ); + if ( !m_xAmbientForm.is() ) + { + Reference< XRowSetSupplier > xSupRowSet( xParent, UNO_QUERY ); + if ( xSupRowSet.is() ) + m_xAmbientForm.set( xSupRowSet->getRowSet(), UNO_QUERY ); + } +} + +void OBoundControlModel::impl_connectDatabaseColumn_noNotify( bool _bFromReload ) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::impl_connectDatabaseColumn_noNotify: not to be called with an external value binding!" ); + // consistency checks + DBG_ASSERT( !( hasField() && !_bFromReload ), + "OBoundControlModel::impl_connectDatabaseColumn_noNotify: the form is just *loaded*, but we already have a field!" ); + + Reference< XRowSet > xRowSet( m_xAmbientForm, UNO_QUERY ); + OSL_ENSURE( xRowSet.is(), "OBoundControlModel::impl_connectDatabaseColumn_noNotify: no row set!" ); + if ( !xRowSet.is() ) + return; + if ( !hasField() || _bFromReload ) + { + // connect to the column + connectToField( xRowSet ); + } + + // now that we're connected (more or less, even if we did not find a column), + // we definitely want to forward any potentially occurring value changes + m_bForwardValueChanges = true; + // let derived classes react on this new connection + m_bLoaded = true; + onConnectedDbColumn( xRowSet ); + // initially transfer the db column value to the control, if we successfully connected to a database column + if ( hasField() ) + initFromField( xRowSet ); +} + +void OBoundControlModel::impl_disconnectDatabaseColumn_noNotify() +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::impl_disconnectDatabaseColumn_noNotify: not to be called with an external value binding!" ); + // let derived classes react on this + onDisconnectedDbColumn(); + if ( hasField() ) + { + getField()->removePropertyChangeListener( PROPERTY_VALUE, this ); + resetField(); + } + + m_xCursor = nullptr; + m_bLoaded = false; +} + +// XLoadListener +void SAL_CALL OBoundControlModel::loaded( const EventObject& _rEvent ) +{ + ControlModelLock aLock( *this ); + FieldChangeNotifier aBoundFieldNotifier( aLock ); + OSL_ENSURE( _rEvent.Source == m_xAmbientForm, "OBoundControlModel::loaded: where does this come from?" ); + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::loaded: we should never reach this with an external value binding!" ); + if ( hasExternalValueBinding() ) + return; + impl_connectDatabaseColumn_noNotify( false ); +} + +void SAL_CALL OBoundControlModel::unloaded( const css::lang::EventObject& /*aEvent*/ ) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::unloaded: we should never reach this with an external value binding!" ); +} + +void SAL_CALL OBoundControlModel::reloading( const css::lang::EventObject& /*aEvent*/ ) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::reloading: we should never reach this with an external value binding!" ); + if ( hasExternalValueBinding() ) + return; + osl::MutexGuard aGuard(m_aMutex); + m_bForwardValueChanges = false; +} + +void SAL_CALL OBoundControlModel::unloading(const css::lang::EventObject& /*aEvent*/) +{ + ControlModelLock aLock( *this ); + FieldChangeNotifier aBoundFieldNotifier( aLock ); + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::unloading: we should never reach this with an external value binding!" ); + if ( hasExternalValueBinding() ) + return; + impl_disconnectDatabaseColumn_noNotify(); +} + +void SAL_CALL OBoundControlModel::reloaded( const EventObject& _rEvent ) +{ + ControlModelLock aLock( *this ); + FieldChangeNotifier aBoundFieldNotifier( aLock ); + OSL_ENSURE( _rEvent.Source == m_xAmbientForm, "OBoundControlModel::reloaded: where does this come from?" ); + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::reloaded: we should never reach this with an external value binding!" ); + if ( hasExternalValueBinding() ) + return; + impl_connectDatabaseColumn_noNotify( true ); +} + +void OBoundControlModel::setControlValue( const Any& _rValue, ValueChangeInstigator _eInstigator ) +{ + m_eControlValueChangeInstigator = _eInstigator; + doSetControlValue( _rValue ); + m_eControlValueChangeInstigator = eOther; +} + +void OBoundControlModel::doSetControlValue( const Any& _rValue ) +{ + OSL_PRECOND( m_xAggregateFastSet.is() && m_xAggregateSet.is(), + "OBoundControlModel::doSetControlValue: invalid aggregate !" ); + OSL_PRECOND( !m_sValuePropertyName.isEmpty() || ( m_nValuePropertyAggregateHandle != -1 ), + "OBoundControlModel::doSetControlValue: please override if you have own value property handling!" ); + try + { + // release our mutex once (it's acquired in one of the calling methods), as setting aggregate properties + // may cause any uno controls belonging to us to lock the solar mutex, which is potentially dangerous with + // our own mutex locked + MutexRelease aRelease( m_aMutex ); + if ( ( m_nValuePropertyAggregateHandle != -1 ) && m_xAggregateFastSet.is() ) + { + m_xAggregateFastSet->setFastPropertyValue( m_nValuePropertyAggregateHandle, _rValue ); + } + + else if ( !m_sValuePropertyName.isEmpty() && m_xAggregateSet.is() ) + { + m_xAggregateSet->setPropertyValue( m_sValuePropertyName, _rValue ); + } + + } + + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OBoundControlModel::doSetControlValue"); + } +} + +void OBoundControlModel::onConnectedValidator( ) +{ + try + { + // if we have an external validator, we do not want the control to force invalid + // inputs to the default value. Instead, invalid inputs should be translated + // to NaN (not a number) + Reference< XPropertySetInfo > xAggregatePropertyInfo; + if ( m_xAggregateSet.is() ) + xAggregatePropertyInfo = m_xAggregateSet->getPropertySetInfo(); + if ( xAggregatePropertyInfo.is() && xAggregatePropertyInfo->hasPropertyByName( PROPERTY_ENFORCE_FORMAT ) ) + m_xAggregateSet->setPropertyValue( PROPERTY_ENFORCE_FORMAT, Any( false ) ); + } + + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OBoundControlModel::onConnectedValidator"); + } + + recheckValidity( false ); +} + +void OBoundControlModel::onDisconnectedValidator( ) +{ + try + { + Reference< XPropertySetInfo > xAggregatePropertyInfo; + if ( m_xAggregateSet.is() ) + xAggregatePropertyInfo = m_xAggregateSet->getPropertySetInfo(); + if ( xAggregatePropertyInfo.is() && xAggregatePropertyInfo->hasPropertyByName( PROPERTY_ENFORCE_FORMAT ) ) + m_xAggregateSet->setPropertyValue( PROPERTY_ENFORCE_FORMAT, Any( true ) ); + } + + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OBoundControlModel::onDisconnectedValidator"); + } + + recheckValidity( false ); +} + +void OBoundControlModel::onConnectedExternalValue( ) +{ + calculateExternalValueType(); +} + +void OBoundControlModel::onConnectedDbColumn( const Reference< XInterface >& /*_rxForm*/ ) +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::onConnectedDbColumn: how this? There's an external value binding!" ); +} + +void OBoundControlModel::onDisconnectedDbColumn() +{ + OSL_PRECOND( !hasExternalValueBinding(), "OBoundControlModel::onDisconnectedDbColumn: how this? There's an external value binding!" ); +} + +// XReset +Any OBoundControlModel::getDefaultForReset() const +{ + return Any(); +} + +void OBoundControlModel::resetNoBroadcast() +{ + setControlValue( getDefaultForReset(), eOther ); +} + +void OBoundControlModel::addResetListener(const Reference<XResetListener>& l) +{ + m_aResetHelper.addResetListener( l ); +} + +void OBoundControlModel::removeResetListener(const Reference<XResetListener>& l) +{ + m_aResetHelper.removeResetListener( l ); +} + +void OBoundControlModel::reset() +{ + if ( !m_aResetHelper.approveReset() ) + return; + ControlModelLock aLock( *this ); + // on a new record? + bool bIsNewRecord = false; + Reference<XPropertySet> xSet( m_xCursor, UNO_QUERY ); + if ( xSet.is() ) + { + try + { + xSet->getPropertyValue( PROPERTY_ISNEW ) >>= bIsNewRecord; + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } + + } + + // cursor on an invalid row? + bool bInvalidCursorPosition = true; + try + { + bInvalidCursorPosition = m_xCursor.is() + && ( m_xCursor->isAfterLast() + || m_xCursor->isBeforeFirst() + ) + && !bIsNewRecord; + } + + catch( const SQLException& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OBoundControlModel::reset: caught an SQL exception!" ); + } + + // #i24495# - don't count the insert row as "invalid" + bool bSimpleReset = + ( !m_xColumn.is() // no connection to a database column + || ( m_xCursor.is() // OR we have an improperly positioned cursor + && bInvalidCursorPosition + ) + || hasExternalValueBinding() // OR we have an external value binding + ); + if ( !bSimpleReset ) + { + // The default values will be set if and only if the current value of the field which we're bound + // to is NULL. + // Else, the current field value should be refreshed + // This behaviour is not completely ... "matured": What should happen if the field as well as the + // control have a default value? + bool bIsNull = true; + // we have to access the field content at least once to get a reliable result by XColumn::wasNull + try + { + // normally, we'd do a getString here. However, this is extremely expensive in the case + // of binary fields. Unfortunately, getString is the only method which is guaranteed + // to *always* succeed, all other getXXX methods may fail if the column is asked for a + // non-convertible type + sal_Int32 nFieldType = DataType::OBJECT; + getField()->getPropertyValue( PROPERTY_FIELDTYPE ) >>= nFieldType; + if ( ( nFieldType == DataType::BINARY ) + || ( nFieldType == DataType::VARBINARY ) + || ( nFieldType == DataType::LONGVARBINARY ) + || ( nFieldType == DataType::OBJECT ) + /*|| ( nFieldType == DataType::CLOB )*/ + ) + m_xColumn->getBinaryStream(); + else if ( nFieldType == DataType::BLOB ) + m_xColumn->getBlob(); + else + m_xColumn->getString(); + bIsNull = m_xColumn->wasNull(); + } + + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + SAL_WARN("forms.component", "OBoundControlModel::reset: this should have succeeded in all cases!"); + } + + bool bNeedValueTransfer = true; + if ( bIsNull ) + { + if ( bIsNewRecord ) + { + // reset the control to its default + resetNoBroadcast(); + // and immediately commit the changes to the DB column, to keep consistency + commitControlValueToDbColumn( true ); + bNeedValueTransfer = false; + } + + } + + if ( bNeedValueTransfer ) + transferDbValueToControl(); + } + + else + { + resetNoBroadcast(); + // transfer to the external binding, if necessary + if ( hasExternalValueBinding() ) + transferControlValueToExternal( aLock ); + } + + // revalidate, if necessary + if ( hasValidator() ) + recheckValidity( true ); + aLock.release(); + m_aResetHelper.notifyResetted(); +} + +void OBoundControlModel::impl_setField_noNotify( const Reference< XPropertySet>& _rxField ) +{ + DBG_ASSERT( !hasExternalValueBinding(), "OBoundControlModel::impl_setField_noNotify: We have an external value binding!" ); + m_xField = _rxField; +} + +bool OBoundControlModel::impl_approveValueBinding_nolock( const Reference< XValueBinding >& _rxBinding ) +{ + if ( !_rxBinding.is() ) + return false; + Sequence< Type > aTypeCandidates; + { + // SYNCHRONIZED > + ::osl::MutexGuard aGuard( m_aMutex ); + aTypeCandidates = getSupportedBindingTypes(); + // < SYNCHRONIZED + } + + for ( auto const & type : std::as_const(aTypeCandidates) ) + { + if ( _rxBinding->supportsType( type ) ) + return true; + } + return false; +} + +void OBoundControlModel::connectExternalValueBinding( + const Reference< XValueBinding >& _rxBinding, ControlModelLock& _rInstanceLock ) +{ + OSL_PRECOND( _rxBinding.is(), "OBoundControlModel::connectExternalValueBinding: invalid binding instance!" ); + OSL_PRECOND( !hasExternalValueBinding( ), "OBoundControlModel::connectExternalValueBinding: precond not met (currently have a binding)!" ); + // if we're connected to a database column, suspend this + if ( hasField() ) + impl_disconnectDatabaseColumn_noNotify(); + // suspend listening for load-related events at out ambient form. + // This is because an external value binding overrules a possible database binding. + if ( isFormListening() ) + doFormListening( false ); + // remember this new binding + m_xExternalBinding = _rxBinding; + // tell the derivee + onConnectedExternalValue(); + try + { + // add as value listener so we get notified when the value changes + Reference< XModifyBroadcaster > xModifiable( m_xExternalBinding, UNO_QUERY ); + if ( xModifiable.is() ) + xModifiable->addModifyListener( this ); + // add as property change listener for some (possibly present) properties we're + // interested in + Reference< XPropertySet > xBindingProps( m_xExternalBinding, UNO_QUERY ); + Reference< XPropertySetInfo > xBindingPropsInfo( xBindingProps.is() ? xBindingProps->getPropertySetInfo() : Reference< XPropertySetInfo >() ); + if ( xBindingPropsInfo.is() ) + { + if ( xBindingPropsInfo->hasPropertyByName( PROPERTY_READONLY ) ) + { + xBindingProps->addPropertyChangeListener( PROPERTY_READONLY, this ); + m_bBindingControlsRO = true; + } + + if ( xBindingPropsInfo->hasPropertyByName( PROPERTY_RELEVANT ) ) + { + xBindingProps->addPropertyChangeListener( PROPERTY_RELEVANT, this ); + m_bBindingControlsEnable = true; + } + + } + + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } + + // propagate our new value + transferExternalValueToControl( _rInstanceLock ); + // if the binding is also a validator, use it, too. This is a constraint of the + // com.sun.star.form.binding.ValidatableBindableFormComponent service + if ( !m_bSupportsValidation ) + return; + + try + { + Reference< XValidator > xAsValidator( _rxBinding, UNO_QUERY ); + if ( xAsValidator.is() ) + setValidator( xAsValidator ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } +} + +void OBoundControlModel::disconnectExternalValueBinding( ) +{ + try + { + // not listening at the binding anymore + Reference< XModifyBroadcaster > xModifiable( m_xExternalBinding, UNO_QUERY ); + if ( xModifiable.is() ) + xModifiable->removeModifyListener( this ); + // remove as property change listener + Reference< XPropertySet > xBindingProps( m_xExternalBinding, UNO_QUERY ); + if ( m_bBindingControlsRO ) + xBindingProps->removePropertyChangeListener( PROPERTY_READONLY, this ); + if ( m_bBindingControlsEnable ) + xBindingProps->removePropertyChangeListener( PROPERTY_RELEVANT, this ); + } + + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OBoundControlModel::disconnectExternalValueBinding"); + } + + // if the binding also acts as our validator, disconnect the validator, too + if ( ( m_xExternalBinding == m_xValidator ) && m_xValidator.is() ) + disconnectValidator( ); + // no binding anymore + m_xExternalBinding.clear(); + // be a load listener at our form, again. This was suspended while we had + // an external value binding in place. + doFormListening( true ); + // re-connect to database column of the new parent + if ( m_xAmbientForm.is() && m_xAmbientForm->isLoaded() ) + impl_connectDatabaseColumn_noNotify( false ); +} + +void SAL_CALL OBoundControlModel::setValueBinding( const Reference< XValueBinding >& _rxBinding ) +{ + OSL_PRECOND( m_bSupportsExternalBinding, "OBoundControlModel::setValueBinding: How did you reach this method?" ); + // the interface for this method should not have been exposed if we do not + // support binding to external data + // allow reset + if ( _rxBinding.is() && !impl_approveValueBinding_nolock( _rxBinding ) ) + { + throw IncompatibleTypesException( + ResourceManager::loadString(RID_STR_INCOMPATIBLE_TYPES), + *this + ); + } + + ControlModelLock aLock( *this ); + // since a ValueBinding overrules any potentially active database binding, the change in a ValueBinding + // might trigger a change in our BoundField. + FieldChangeNotifier aBoundFieldNotifier( aLock ); + // disconnect from the old binding + if ( hasExternalValueBinding() ) + disconnectExternalValueBinding( ); + // connect to the new binding + if ( _rxBinding.is() ) + connectExternalValueBinding( _rxBinding, aLock ); +} + +Reference< XValueBinding > SAL_CALL OBoundControlModel::getValueBinding( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + OSL_PRECOND( m_bSupportsExternalBinding, "OBoundControlModel::getValueBinding: How did you reach this method?" ); + // the interface for this method should not have been exposed if we do not + // support binding to external data + return m_xExternalBinding; +} + +void SAL_CALL OBoundControlModel::modified( const EventObject& _rEvent ) +{ + ControlModelLock aLock( *this ); + OSL_PRECOND( hasExternalValueBinding(), "OBoundControlModel::modified: Where did this come from?" ); + if ( !m_bTransferringValue && ( m_xExternalBinding == _rEvent.Source ) && m_xExternalBinding.is() ) + { + transferExternalValueToControl( aLock ); + } +} + +void OBoundControlModel::transferDbValueToControl( ) +{ + try + { + setControlValue( translateDbColumnToControlValue(), eDbColumnBinding ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } +} + +void OBoundControlModel::transferExternalValueToControl( ControlModelLock& _rInstanceLock ) +{ + Reference< XValueBinding > xExternalBinding( m_xExternalBinding ); + Type aValueExchangeType( getExternalValueType() ); + _rInstanceLock.release(); + // UNSAFE > + Any aExternalValue; + try + { + aExternalValue = xExternalBinding->getValue( aValueExchangeType ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } + // < UNSAFE + _rInstanceLock.acquire(); + setControlValue( translateExternalValueToControlValue( aExternalValue ), eExternalBinding ); +} + +void OBoundControlModel::transferControlValueToExternal( ControlModelLock& _rInstanceLock ) +{ + OSL_PRECOND( m_bSupportsExternalBinding && hasExternalValueBinding(), + "OBoundControlModel::transferControlValueToExternal: precondition not met!" ); + if ( !m_xExternalBinding.is() ) + return; + + Any aExternalValue( translateControlValueToExternalValue() ); + m_bTransferringValue = true; + _rInstanceLock.release(); + // UNSAFE > + try + { + m_xExternalBinding->setValue( aExternalValue ); + } + + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("forms.component"); + } + + // < UNSAFE + _rInstanceLock.acquire(); + m_bTransferringValue = false; +} + +Sequence< Type > OBoundControlModel::getSupportedBindingTypes() +{ + return Sequence< Type >( &m_aValuePropertyType, 1 ); +} + +void OBoundControlModel::calculateExternalValueType() +{ + m_aExternalValueType = Type(); + if ( !m_xExternalBinding.is() ) + return; + const Sequence< Type > aTypeCandidates( getSupportedBindingTypes() ); + for ( auto const & typeCandidate : aTypeCandidates ) + { + if ( m_xExternalBinding->supportsType( typeCandidate ) ) + { + m_aExternalValueType = typeCandidate; + break; + } + } +} + +Any OBoundControlModel::translateExternalValueToControlValue( const Any& _rExternalValue ) const +{ + OSL_PRECOND( m_bSupportsExternalBinding && hasExternalValueBinding(), + "OBoundControlModel::translateExternalValueToControlValue: precondition not met!" ); + Any aControlValue( _rExternalValue ); + // if the external value is VOID, and our value property is not allowed to be VOID, + // then default-construct a value + if ( !aControlValue.hasValue() && !m_bValuePropertyMayBeVoid ) + aControlValue.setValue( nullptr, m_aValuePropertyType ); + // out of here + return aControlValue; +} + +Any OBoundControlModel::translateControlValueToExternalValue( ) const +{ + return getControlValue( ); +} + +Any OBoundControlModel::translateControlValueToValidatableValue( ) const +{ + OSL_PRECOND( m_xValidator.is(), "OBoundControlModel::translateControlValueToValidatableValue: no validator, so why should I?" ); + if ( ( m_xValidator == m_xExternalBinding ) && m_xValidator.is() ) + return translateControlValueToExternalValue(); + return getControlValue(); +} + +Any OBoundControlModel::getControlValue( ) const +{ + OSL_PRECOND( m_xAggregateFastSet.is() && m_xAggregateSet.is(), + "OBoundControlModel::getControlValue: invalid aggregate !" ); + OSL_PRECOND( !m_sValuePropertyName.isEmpty() || ( m_nValuePropertyAggregateHandle != -1 ), + "OBoundControlModel::getControlValue: please override if you have own value property handling!" ); + // determine the current control value + Any aControlValue; + if ( ( m_nValuePropertyAggregateHandle != -1 ) && m_xAggregateFastSet.is() ) + { + aControlValue = m_xAggregateFastSet->getFastPropertyValue( m_nValuePropertyAggregateHandle ); + } + + else if ( !m_sValuePropertyName.isEmpty() && m_xAggregateSet.is() ) + { + aControlValue = m_xAggregateSet->getPropertyValue( m_sValuePropertyName ); + } + return aControlValue; +} + +void OBoundControlModel::connectValidator( const Reference< XValidator >& _rxValidator ) +{ + OSL_PRECOND( _rxValidator.is(), "OBoundControlModel::connectValidator: invalid validator instance!" ); + OSL_PRECOND( !hasValidator( ), "OBoundControlModel::connectValidator: precond not met (have a validator currently)!" ); + m_xValidator = _rxValidator; + + // add as value listener so we get notified when the value changes + if ( m_xValidator.is() ) + { + try + { + m_xValidator->addValidityConstraintListener( this ); + } + + catch( const RuntimeException& ) + { + } + } + onConnectedValidator( ); +} + +void OBoundControlModel::disconnectValidator( ) +{ + OSL_PRECOND( hasValidator( ), "OBoundControlModel::connectValidator: precond not met (don't have a validator currently)!" ); + + // add as value listener so we get notified when the value changes + if ( m_xValidator.is() ) + { + try + { + m_xValidator->removeValidityConstraintListener( this ); + } + + catch( const RuntimeException& ) + { + } + } + + m_xValidator.clear(); + + onDisconnectedValidator( ); +} + +void SAL_CALL OBoundControlModel::setValidator( const Reference< XValidator >& _rxValidator ) +{ + osl::MutexGuard aGuard( m_aMutex ); + OSL_PRECOND( m_bSupportsValidation, "OBoundControlModel::setValidator: How did you reach this method?" ); + // the interface for this method should not have been exposed if we do not + // support validation + + // early out if the validator does not change + if ( _rxValidator == m_xValidator ) + return; + + if ( m_xValidator.is() && ( m_xValidator == m_xExternalBinding ) ) + throw VetoException( + ResourceManager::loadString(RID_STR_INVALID_VALIDATOR), + *this + ); + + // disconnect from the old validator + if ( hasValidator() ) + disconnectValidator( ); + + // connect to the new validator + if ( _rxValidator.is() ) + connectValidator( _rxValidator ); +} + +Reference< XValidator > SAL_CALL OBoundControlModel::getValidator( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + OSL_PRECOND( m_bSupportsValidation, "OBoundControlModel::getValidator: How did you reach this method?" ); + // the interface for this method should not have been exposed if we do not + // support validation + + return m_xValidator; +} + +void SAL_CALL OBoundControlModel::validityConstraintChanged( const EventObject& /*Source*/ ) +{ + osl::MutexGuard aGuard( m_aMutex ); + OSL_PRECOND( m_bSupportsValidation, "OBoundControlModel::validityConstraintChanged: How did you reach this method?" ); + // the interface for this method should not have been exposed if we do not + // support validation + + recheckValidity( false ); +} + +sal_Bool SAL_CALL OBoundControlModel::isValid( ) +{ + return m_bIsCurrentValueValid; +} + +css::uno::Any OBoundControlModel::getCurrentFormComponentValue() const +{ + if ( hasValidator() ) + return translateControlValueToValidatableValue(); + return getControlValue(); +} + +Any SAL_CALL OBoundControlModel::getCurrentValue( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return getCurrentFormComponentValue(); +} + +void SAL_CALL OBoundControlModel::addFormComponentValidityListener( const Reference< validation::XFormComponentValidityListener >& Listener ) +{ + if ( Listener.is() ) + m_aFormComponentListeners.addInterface( Listener ); +} + +void SAL_CALL OBoundControlModel::removeFormComponentValidityListener( const Reference< validation::XFormComponentValidityListener >& Listener ) +{ + if ( Listener.is() ) + m_aFormComponentListeners.removeInterface( Listener ); +} + +void OBoundControlModel::recheckValidity( bool _bForceNotification ) +{ + try + { + bool bIsCurrentlyValid = true; + if ( hasValidator() ) + bIsCurrentlyValid = m_xValidator->isValid( translateControlValueToValidatableValue() ); + + if ( ( bIsCurrentlyValid != m_bIsCurrentValueValid ) || _bForceNotification ) + { + m_bIsCurrentValueValid = bIsCurrentlyValid; + + // release our mutex for the notifications + MutexRelease aRelease( m_aMutex ); + m_aFormComponentListeners.notifyEach( &validation::XFormComponentValidityListener::componentValidityChanged, EventObject( *this ) ); + } + + } + + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("forms.component", "OBoundControlModel::recheckValidity"); + } +} + +void OBoundControlModel::describeFixedProperties( Sequence< Property >& _rProps ) const +{ + OControlModel::describeFixedProperties( _rProps ); + sal_Int32 nOldCount = _rProps.getLength(); + _rProps.realloc( nOldCount + 5); + css::beans::Property* pProperties = _rProps.getArray() + nOldCount; + *pProperties++ = css::beans::Property(PROPERTY_CONTROLSOURCE, PROPERTY_ID_CONTROLSOURCE, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND); + *pProperties++ = css::beans::Property(PROPERTY_BOUNDFIELD, PROPERTY_ID_BOUNDFIELD, cppu::UnoType<XPropertySet>::get(), + css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::READONLY | css::beans::PropertyAttribute::TRANSIENT); + *pProperties++ = css::beans::Property(PROPERTY_CONTROLLABEL, PROPERTY_ID_CONTROLLABEL, cppu::UnoType<XPropertySet>::get(), + css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEVOID); + *pProperties++ = css::beans::Property(PROPERTY_CONTROLSOURCEPROPERTY, PROPERTY_ID_CONTROLSOURCEPROPERTY, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::READONLY | css::beans::PropertyAttribute::TRANSIENT); + *pProperties++ = css::beans::Property(PROPERTY_INPUT_REQUIRED, PROPERTY_ID_INPUT_REQUIRED, cppu::UnoType<bool>::get(), + css::beans::PropertyAttribute::BOUND); + DBG_ASSERT( pProperties == _rProps.getArray() + _rProps.getLength(), "<...>::describeFixedProperties/getInfoHelper: forgot to adjust the count ?"); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |