FormComponent.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include "cloneable.hxx"
#include "propertybaghelper.hxx"
#include "resettable.hxx"
#include "windowstateguard.hxx"
 
#include <com/sun/star/awt/XControl.hpp>
#include <com/sun/star/beans/XPropertyAccess.hpp>
#include <com/sun/star/beans/XPropertyContainer.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/form/binding/XBindableValue.hpp>
#include <com/sun/star/form/validation/XValidatableFormComponent.hpp>
#include <com/sun/star/form/validation/XValidityConstraintListener.hpp>
#include <com/sun/star/form/XBoundComponent.hpp>
#include <com/sun/star/form/XBoundControl.hpp>
#include <com/sun/star/form/XFormComponent.hpp>
#include <com/sun/star/form/XLoadListener.hpp>
#include <com/sun/star/form/XReset.hpp>
#include <com/sun/star/io/XPersistObject.hpp>
#include <com/sun/star/lang/XEventListener.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/sdb/XColumn.hpp>
#include <com/sun/star/sdb/XColumnUpdate.hpp>
#include <com/sun/star/sdb/XRowSetChangeListener.hpp>
#include <com/sun/star/sdbc/XRowSet.hpp>
#include <com/sun/star/uno/XAggregation.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/util/XCloneable.hpp>
#include <com/sun/star/util/XModifyListener.hpp>
#include <com/sun/star/form/XLoadable.hpp>
 
#include <comphelper/interfacecontainer3.hxx>
#include <comphelper/propagg.hxx>
#include <comphelper/propmultiplex.hxx>
#include <comphelper/uno3.hxx>
#include <cppuhelper/component.hxx>
#include <cppuhelper/implbase1.hxx>
#include <cppuhelper/implbase2.hxx>
#include <cppuhelper/implbase3.hxx>
#include <cppuhelper/implbase4.hxx>
#include <cppuhelper/implbase7.hxx>
#include <cppuhelper/propshlp.hxx>
#include <osl/mutex.hxx>
#include <rtl/ustring.hxx>
 
 
namespace frm
{
 
 
    // default tab index for components
    const sal_Int16 FRM_DEFAULT_TABINDEX = 0;
 
    class OControlModel;
 
 
    //= ControlModelLock
 
    class ControlModelLock
    {
    public:
        ControlModelLock( OControlModel& _rModel )
            :m_rModel( _rModel )
            ,m_bLocked( false )
        {
            acquire();
        }
 
        ~ControlModelLock()
        {
            if ( m_bLocked )
                release();
        }
        inline void acquire();
        inline void release();
 
        OControlModel& getModel() const { return m_rModel; };
 
        void    addPropertyNotification(
                    const sal_Int32 _nHandle,
                    const css::uno::Any& _rOldValue,
                    const css::uno::Any& _rNewValue
                );
 
    private:
        void    impl_notifyAll_nothrow();
 
        OControlModel&                              m_rModel;
        bool                                        m_bLocked;
        std::vector< sal_Int32 >                    m_aHandles;
        std::vector< css::uno::Any >                m_aOldValues;
        std::vector< css::uno::Any >                m_aNewValues;
 
        ControlModelLock( const ControlModelLock& ) = delete;
        ControlModelLock& operator=( const ControlModelLock& ) = delete;
    };
 
 
//= OControl
//= base class for form layer controls
 
typedef ::cppu::ImplHelper3 <   css::awt::XControl
                            ,   css::lang::XEventListener
                            ,   css::lang::XServiceInfo
                            > OControl_BASE;
 
class OControl  :public ::cppu::OComponentHelper
                ,public OControl_BASE
{
protected:
    ::osl::Mutex                                m_aMutex;
    css::uno::Reference< css::awt::XControl >   m_xControl;
    css::uno::Reference< css::uno::XAggregation>
                                                m_xAggregate;
 
    css::uno::Reference< css::uno::XComponentContext >
                                                m_xContext;
    WindowStateGuard                            m_aWindowStateGuard;
 
public:
    OControl(
        const css::uno::Reference< css::uno::XComponentContext >& _rFactory,
        const OUString& _rAggregateService,
        const bool _bSetDelegator = true
    );
 
protected:
    virtual ~OControl() override;
 
    void    doSetDelegator();
    void    doResetDelegator();
 
// UNO
    DECLARE_UNO3_AGG_DEFAULTS(OControl, OComponentHelper)
    virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override;
 
// XTypeProvider
    virtual css::uno::Sequence<sal_Int8>           SAL_CALL getImplementationId() override;
    virtual css::uno::Sequence< css::uno::Type>   SAL_CALL getTypes() override;
 
// OComponentHelper
    virtual void SAL_CALL disposing() override;
 
// XComponent (as base of XControl)
    virtual void SAL_CALL dispose(  ) override
        { OComponentHelper::dispose(); }
    virtual void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener>& _rxListener) override
        { OComponentHelper::addEventListener(_rxListener); }
    virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener>& _rxListener) override
        { OComponentHelper::removeEventListener(_rxListener); }
 
// XEventListener
    virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
 
// XServiceInfo
    virtual sal_Bool SAL_CALL           supportsService(const OUString& ServiceName) override;
    virtual css::uno::Sequence<OUString> SAL_CALL     getSupportedServiceNames() override;
    virtual OUString SAL_CALL    getImplementationName() override = 0;
 
// XControl
    virtual void                                        SAL_CALL setContext(const css::uno::Reference<css::uno::XInterface>& Context) override;
    virtual css::uno::Reference<css::uno::XInterface>   SAL_CALL getContext() override;
    virtual void                                        SAL_CALL createPeer(const css::uno::Reference<css::awt::XToolkit>& Toolkit, const css::uno::Reference<css::awt::XWindowPeer>& Parent) override;
    virtual css::uno::Reference<css::awt::XWindowPeer>  SAL_CALL getPeer() override;
    virtual sal_Bool                                    SAL_CALL setModel(const css::uno::Reference<css::awt::XControlModel>& Model) override;
    virtual css::uno::Reference<css::awt::XControlModel> SAL_CALL getModel() override;
    virtual css::uno::Reference<css::awt::XView>        SAL_CALL getView() override;
    virtual void                                        SAL_CALL setDesignMode(sal_Bool bOn) override;
    virtual sal_Bool                                    SAL_CALL isDesignMode() override;
    virtual sal_Bool                                    SAL_CALL isTransparent() override;
 
protected:
    virtual css::uno::Sequence< css::uno::Type>   _getTypes();
        // overwrite this and call the base class if you have additional types
 
    css::uno::Sequence< OUString > getAggregateServiceNames() const;
 
private:
    void    impl_resetStateGuard_nothrow();
};
 
// a form control implementing the XBoundControl interface
typedef ::cppu::ImplHelper1 <   css::form::XBoundControl
                            >  OBoundControl_BASE;
class OBoundControl :public OControl
                    ,public OBoundControl_BASE
{
    bool            m_bLocked : 1;
 
public:
    OBoundControl(
        const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
        const OUString& _rAggregateService,
        const bool _bSetDelegator = true
    );
 
    virtual ~OBoundControl() override;
 
    DECLARE_UNO3_AGG_DEFAULTS(OBoundControl, OControl)
    virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override;
 
    // XBoundControl
    virtual sal_Bool SAL_CALL   getLock() override;
    virtual void SAL_CALL       setLock(sal_Bool _bLock) override;
        // default implementation just disables the controls, overwrite _setLock to change this behaviour
 
    // XControl
    virtual sal_Bool SAL_CALL setModel(const css::uno::Reference< css::awt::XControlModel >& Model) override;
 
    // XEventListener
    virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
 
    // OComponentHelper
    virtual void SAL_CALL disposing() override;
 
protected:
    virtual css::uno::Sequence< css::uno::Type>   _getTypes() override;
    // implement the lock setting
    void         _setLock(bool _bLock);
};
 
 
//= OControlModel
//= model of a form layer control
 
//added for exporting OCX control
#define INVALID_OBJ_ID_IN_MSO     0xFFFF
 
typedef ::cppu::ImplHelper7 <   css::form::XFormComponent
                            ,   css::io::XPersistObject
                            ,   css::container::XNamed
                            ,   css::lang::XServiceInfo
                            ,   css::util::XCloneable
                            ,   css::beans::XPropertyContainer
                            ,   css::beans::XPropertyAccess
                            >   OControlModel_BASE;
 
class OControlModel :public ::cppu::OComponentHelper
                    ,public comphelper::OPropertySetAggregationHelper
                    ,public OControlModel_BASE
                    ,public OCloneableAggregation
                    ,public IPropertyBagHelperContext
{
 
protected:
    css::uno::Reference<css::uno::XComponentContext>  m_xContext;
 
    ::osl::Mutex                    m_aMutex;
    oslInterlockedCount             m_lockCount;
 
    css::uno::Reference<css::uno::XInterface>                    m_xParent;                  // ParentComponent
    PropertyBagHelper               m_aPropertyBagHelper;
 
    const css::uno::Reference<css::uno::XComponentContext>&
        getContext() const { return m_xContext; }
 
// <properties>
    OUString                 m_aName;                    // name of the control
    OUString                 m_aTag;                     // tag for additional data
    sal_Int16                       m_nTabIndex;                // index within the taborder
    sal_Int16                       m_nClassId;                 // type of the control
    bool                        m_bNativeLook;              // should the control use the native platform look?
    bool                        m_bStandardTheme;           // should the default control colors be 'standard' or use the native platform theme?
    bool                        m_bGenerateVbEvents;        // should the control generate fake vba events
    //added for exporting OCX control
    sal_Int16                       m_nControlTypeinMSO;        //keep the MS office control type for exporting to MS binary file
    sal_uInt16                      m_nObjIDinMSO;              //keep the OCX control obj id for exporting to MS binary file
// </properties>
 
 
protected:
    OControlModel(
        const css::uno::Reference< css::uno::XComponentContext>& _rFactory,   // factory to create the aggregate with
        const OUString& _rUnoControlModelTypeName,                       // service name of te model to aggregate
        const OUString& rDefault = OUString(),                    // service name of the default control
        const bool _bSetDelegator = true                                // set to sal_False if you want to call setDelegator later (after returning from this ctor)
    );
    OControlModel(
        const OControlModel* _pOriginal,                                        // the original object to clone
        const css::uno::Reference< css::uno::XComponentContext>& _rFactory,   // factory to create the aggregate with
        const bool _bCloneAggregate = true,                             // should the aggregate of the original be cloned, too?
        const bool _bSetDelegator = true                                // set to sal_False if you want to call setDelegator later (after returning from this ctor)
    );
    virtual ~OControlModel() override;
 
    virtual void clonedFrom( const OControlModel* _pOriginal );
 
    using OComponentHelper::rBHelper;
 
    virtual css::uno::Sequence< css::uno::Type>   _getTypes();
 
    void    readHelpTextCompatibly(const css::uno::Reference< css::io::XObjectInputStream >& _rxInStream);
    void    writeHelpTextCompatibly(const css::uno::Reference< css::io::XObjectOutputStream >& _rxOutStream);
 
    void    doSetDelegator();
    void    doResetDelegator();
 
    css::uno::Sequence< OUString > getAggregateServiceNames() const;
 
public:
    DECLARE_UNO3_AGG_DEFAULTS(OControl, OComponentHelper)
    virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override;
 
// XTypeProvider
    virtual css::uno::Sequence<sal_Int8>           SAL_CALL getImplementationId() override;
    virtual css::uno::Sequence< css::uno::Type>   SAL_CALL getTypes() override;
 
// OComponentHelper
    virtual void SAL_CALL disposing() override;
 
// XNamed
    virtual OUString SAL_CALL    getName() override;
    virtual void SAL_CALL               setName(const OUString& aName) override;
 
// XServiceInfo
    virtual sal_Bool SAL_CALL           supportsService(const OUString& ServiceName) override;
    virtual css::uno::Sequence<OUString> SAL_CALL     getSupportedServiceNames() override;
    virtual OUString SAL_CALL    getImplementationName() override = 0;
 
// XServiceInfo - static version(s)
    static  css::uno::Sequence<OUString> getSupportedServiceNames_Static();
 
// XPersistObject
    virtual OUString SAL_CALL    getServiceName() override = 0;
    virtual void SAL_CALL
        write(const css::uno::Reference< css::io::XObjectOutputStream>& _rxOutStream) override;
    virtual void SAL_CALL
        read(const css::uno::Reference< css::io::XObjectInputStream>& _rxInStream) override;
 
// XChild (base of XFormComponent)
    virtual css::uno::Reference<css::uno::XInterface> SAL_CALL   getParent() override;
    virtual void SAL_CALL           setParent(const css::uno::Reference<css::uno::XInterface>& Parent) override;
 
// XEventListener
    virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
 
// XPropertySet
    virtual void SAL_CALL getFastPropertyValue(css::uno::Any& rValue, sal_Int32 nHandle) const override;
    virtual sal_Bool SAL_CALL convertFastPropertyValue(
                css::uno::Any& _rConvertedValue, css::uno::Any& _rOldValue, sal_Int32 _nHandle, const css::uno::Any& _rValue ) override;
    virtual void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue ) override;
    using ::cppu::OPropertySetHelper::getFastPropertyValue;
 
// css::beans::XPropertyState
    virtual css::beans::PropertyState getPropertyStateByHandle(sal_Int32 nHandle) override;
    virtual void setPropertyToDefaultByHandle(sal_Int32 nHandle) override;
    virtual css::uno::Any getPropertyDefaultByHandle( sal_Int32 nHandle ) const override;
 
// XCloneable
    virtual css::uno::Reference< css::util::XCloneable > SAL_CALL createClone(  ) override = 0;
 
// XPropertyContainer
    virtual void SAL_CALL addProperty( const OUString& Name, ::sal_Int16 Attributes, const css::uno::Any& DefaultValue ) override;
    virtual void SAL_CALL removeProperty( const OUString& Name ) override;
 
// XPropertyAccess
    virtual css::uno::Sequence< css::beans::PropertyValue > SAL_CALL getPropertyValues(  ) override;
    virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< css::beans::PropertyValue >& aProps ) override;
 
protected:
    using OPropertySetAggregationHelper::setPropertyValues;
    using OPropertySetAggregationHelper::getPropertyValues;
 
protected:
    virtual void writeAggregate( const css::uno::Reference< css::io::XObjectOutputStream >& _rxOutStream ) const;
    virtual void readAggregate( const css::uno::Reference< css::io::XObjectInputStream >& _rxInStream );
 
protected:
    // XPropertySet
    virtual css::uno::Reference< css::beans::XPropertySetInfo> SAL_CALL getPropertySetInfo() override;
    // OPropertySetHelper
    virtual cppu::IPropertyArrayHelper& SAL_CALL getInfoHelper() override;
 
    virtual void describeFixedProperties(
        css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps
    ) const;
 
    // IPropertyBagHelperContext
    virtual ::osl::Mutex&   getMutex() override;
    virtual void            describeFixedAndAggregateProperties(
        css::uno::Sequence< css::beans::Property >& _out_rFixedProperties,
        css::uno::Sequence< css::beans::Property >& _out_rAggregateProperties
    ) const override;
    virtual css::uno::Reference< css::beans::XMultiPropertySet >
                            getPropertiesInterface() override;
 
    virtual void describeAggregateProperties(
        css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
    ) const;
 
public:
    struct LockAccess { friend class ControlModelLock; private: LockAccess() { } };
 
    void                lockInstance( LockAccess );
    oslInterlockedCount unlockInstance( LockAccess );
 
    void                firePropertyChanges(
                            const std::vector< sal_Int32 >& _rHandles,
                            const std::vector< css::uno::Any >& _rOldValues,
                            const std::vector< css::uno::Any >& _rNewValues,
                            LockAccess
                        );
 
    ::osl::Mutex&
                        getInstanceMutex() { return m_aMutex; }
};
 
//= OBoundControlModel
//= model of a form layer control which is bound to a data source field
 
typedef ::cppu::ImplHelper4 <   css::form::XLoadListener
                            ,   css::form::XReset
                            ,   css::beans::XPropertyChangeListener
                            ,   css::sdb::XRowSetChangeListener
                            >   OBoundControlModel_BASE1;
 
// separated into an own base class since derivees can disable the support for this
// interface, thus we want to easily exclude it in the queryInterface and getTypes
typedef ::cppu::ImplHelper1 <   css::form::XBoundComponent
                            >   OBoundControlModel_COMMITTING;
 
// ditto
typedef ::cppu::ImplHelper2 <   css::form::binding::XBindableValue
                            ,   css::util::XModifyListener
                            >   OBoundControlModel_BINDING;
 
// ditto
typedef ::cppu::ImplHelper2 <   css::form::validation::XValidityConstraintListener
                            ,   css::form::validation::XValidatableFormComponent
                            >   OBoundControlModel_VALIDATION;
 
class OBoundControlModel    :public OControlModel
                            ,public OBoundControlModel_BASE1
                            ,public OBoundControlModel_COMMITTING
                            ,public OBoundControlModel_BINDING
                            ,public OBoundControlModel_VALIDATION
                            ,public ::comphelper::OPropertyChangeListener
{
protected:
    enum ValueChangeInstigator
    {
        eDbColumnBinding,
        eExternalBinding,
        eOther
    };
 
private:
    css::uno::Reference< css::beans::XPropertySet >
                                        m_xField;
    // the form which controls supplies the field we bind to.
    css::uno::Reference< css::form::XLoadable >
                                        m_xAmbientForm;
 
    OUString                            m_sValuePropertyName;
    sal_Int32                           m_nValuePropertyAggregateHandle;
    sal_Int32                           m_nFieldType;
    css::uno::Type                      m_aValuePropertyType;
    bool                                m_bValuePropertyMayBeVoid;
 
    ResetHelper                         m_aResetHelper;
    ::comphelper::OInterfaceContainerHelper3<css::form::XUpdateListener>
                                        m_aUpdateListeners;
    ::comphelper::OInterfaceContainerHelper3<css::form::validation::XFormComponentValidityListener>
                                        m_aFormComponentListeners;
 
    css::uno::Reference< css::form::binding::XValueBinding >
                                        m_xExternalBinding;
    css::uno::Reference< css::form::validation::XValidator >
                                        m_xValidator;
    css::uno::Type                      m_aExternalValueType;
 
// <properties>
    OUString                            m_aControlSource;           // data source, name of the field
    css::uno::Reference< css::beans::XPropertySet >
                                        m_xLabelControl;            // reference to a sibling control (model) which is our label
    bool                                m_bInputRequired;
// </properties>
 
    rtl::Reference<::comphelper::OPropertyChangeMultiplexer>
                                m_pAggPropMultiplexer;
 
    bool                        m_bFormListening            : 1;    // are we currently a XLoadListener at our ambient form?
    bool                    m_bLoaded                   : 1;
    bool                    m_bRequired                 : 1;
    const bool              m_bCommitable               : 1;    // do we support XBoundComponent?
    const bool              m_bSupportsExternalBinding  : 1;    // do we support XBindableValue?
    const bool              m_bSupportsValidation       : 1;    // do we support XValidatable?
    bool                    m_bForwardValueChanges      : 1;    // do we currently handle changes in the bound database field?
    bool                    m_bTransferringValue        : 1;    // true if we're currently transferring our value to an external binding
    bool                    m_bIsCurrentValueValid      : 1;    // flag specifying whether our current value is valid, relative to our external validator
    bool                    m_bBindingControlsRO        : 1;    // is our ReadOnly property currently controlled by our external binding?
    bool                    m_bBindingControlsEnable    : 1;    // is our Enabled property currently controlled by our external binding?
 
    ValueChangeInstigator       m_eControlValueChangeInstigator;
 
protected:
    OUString                     m_aLabelServiceName;
        // when setting the label for our control (property FM_PROP_CONTROLLABEL, member m_xLabelControl),
        // we accept only objects supporting an XControlModel interface, an XServiceInfo interface and
        // support for a service (XServiceInfo::supportsService) determined by this string.
        // Any other arguments will throw an IllegalArgumentException.
        // The default value is FM_COMPONENT_FIXEDTEXT.
 
    css::uno::Reference< css::sdbc::XRowSet >
                                        m_xCursor;
    css::uno::Reference< css::sdb::XColumnUpdate >
                                        m_xColumnUpdate;
    css::uno::Reference< css::sdb::XColumn >
                                        m_xColumn;
 
protected:
    sal_Int32            getValuePropertyAggHandle( ) const  { return m_nValuePropertyAggregateHandle; }
    const OUString&      getControlSource( ) const           { return m_aControlSource; }
    bool                 isRequired() const                  { return m_bRequired; }
    bool                 isLoaded() const                    { return m_bLoaded; }
 
protected:
 
    OBoundControlModel(
        const css::uno::Reference< css::uno::XComponentContext>& _rxContext,
                                                            // factory to create the aggregate with
        const OUString& _rUnoControlModelTypeName,   // service name of te model to aggregate
        const OUString& _rDefault,                   // service name of the default control
        const bool _bCommitable,                        // is the control (model) committable?
        const bool _bSupportExternalBinding,            // set to sal_True if you want to support XBindableValue
        const bool _bSupportsValidation                 // set to sal_True if you want to support XValidatable
    );
    OBoundControlModel(
        const OBoundControlModel* _pOriginal,               // the original object to clone
        const css::uno::Reference< css::uno::XComponentContext>& _rxContext
                                                            // factory to create the aggregate with
    );
    virtual ~OBoundControlModel() override;
 
    virtual void clonedFrom( const OControlModel* _pOriginal ) override;
 
    void                    initValueProperty(
                                const OUString& _rValuePropertyName,
                                sal_Int32 _nValuePropertyExternalHandle
                            );
 
    void                    initOwnValueProperty(
                                const OUString& i_rValuePropertyName
                            );
 
    void                    suspendValueListening( );
 
    void                    resumeValueListening( );
 
    void                    onValuePropertyChange( ControlModelLock& i_rControLock );
 
    void                    startAggregatePropertyListening( const OUString& _rPropertyName );
 
    virtual css::uno::Any
                            getDefaultForReset() const;
 
    virtual css::uno::Any
                            translateDbColumnToControlValue( ) = 0;
 
    virtual css::uno::Sequence< css::uno::Type >
                            getSupportedBindingTypes();
 
    virtual css::uno::Any
                            translateExternalValueToControlValue( const css::uno::Any& _rExternalValue ) const;
 
    virtual css::uno::Any
                            translateControlValueToExternalValue( ) const;
 
    virtual bool        commitControlValueToDbColumn(
                                bool _bPostReset
                            ) = 0;
 
            void            setControlValue(
                                const css::uno::Any& _rValue,
                                ValueChangeInstigator _eInstigator
                            );
    virtual void            doSetControlValue(
                                const css::uno::Any& _rValue
                            );
 
    virtual css::uno::Any
                            getControlValue( ) const;
 
    virtual void            onConnectedDbColumn( const css::uno::Reference< css::uno::XInterface >& _rxForm );
    virtual void            onDisconnectedDbColumn();
 
    virtual void            onConnectedExternalValue( );
 
    void                    onConnectedValidator( );
    void                    onDisconnectedValidator( );
 
    virtual bool        approveDbColumnType(sal_Int32 _nColumnType);
 
    virtual css::uno::Any
                            translateControlValueToValidatableValue( ) const;
 
    virtual css::uno::Any
                            getCurrentFormComponentValue() const;
 
    void    writeCommonProperties(const css::uno::Reference< css::io::XObjectOutputStream>& _rxOutStream);
    void    readCommonProperties(const css::uno::Reference< css::io::XObjectInputStream>& _rxInStream);
    // the next method may be used in derived classes's read when an unknown version is encountered
    void    defaultCommonProperties();
 
    virtual void            resetNoBroadcast();
 
    virtual css::uno::Sequence< css::uno::Type>   _getTypes() override;
 
    void    impl_setField_noNotify(
                const css::uno::Reference< css::beans::XPropertySet>& _rxField
            );
    bool hasField() const
    {
        return m_xField.is();
    }
    sal_Int32 getFieldType() const
    {
        return m_nFieldType;
    }
 
    // OControlModel's property handling
    virtual void describeFixedProperties(
        css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps
    ) const override;
 
public:
    const css::uno::Reference< css::beans::XPropertySet>& getField() const
    {
        return m_xField;
    }
 
public:
    // UNO link
    DECLARE_UNO3_AGG_DEFAULTS(OBoundControlModel, OControlModel)
    virtual css::uno::Any SAL_CALL queryAggregation( const css::uno::Type& _rType ) override;
 
    // OComponentHelper
    virtual void SAL_CALL disposing() override;
 
    // XReset
    virtual void SAL_CALL reset(  ) override;
    virtual void SAL_CALL addResetListener( const css::uno::Reference< css::form::XResetListener >& aListener ) override;
    virtual void SAL_CALL removeResetListener( const css::uno::Reference< css::form::XResetListener >& aListener ) override;
 
    // XServiceInfo
    virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames(  ) override;
 
    // XServiceInfo - static version
    static  css::uno::Sequence<OUString> getSupportedServiceNames_Static();
 
    // XChild
    virtual void SAL_CALL setParent( const css::uno::Reference< css::uno::XInterface >& Parent ) override;
 
    // XPersistObject
    virtual void SAL_CALL write( const css::uno::Reference< css::io::XObjectOutputStream >& OutStream ) override;
    virtual void SAL_CALL read( const css::uno::Reference< css::io::XObjectInputStream >& InStream ) override;
 
    // XBoundComponent
    virtual sal_Bool SAL_CALL commit() override;
 
    // XUpdateBroadcaster (base of XBoundComponent)
    virtual void SAL_CALL addUpdateListener( const css::uno::Reference< css::form::XUpdateListener >& aListener ) override;
    virtual void SAL_CALL removeUpdateListener( const css::uno::Reference< css::form::XUpdateListener >& aListener ) override;
 
    // XPropertySet
    virtual void SAL_CALL getFastPropertyValue(css::uno::Any& rValue, sal_Int32 nHandle) const override;
    virtual sal_Bool SAL_CALL convertFastPropertyValue(
                css::uno::Any& _rConvertedValue, css::uno::Any& _rOldValue, sal_Int32 _nHandle, const css::uno::Any& _rValue ) override;
    virtual void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue ) override;
    using ::cppu::OPropertySetHelper::getFastPropertyValue;
 
// css::beans::XPropertyState
    virtual css::uno::Any getPropertyDefaultByHandle( sal_Int32 nHandle ) const override;
 
// XEventListener
    virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
 
// XPropertyChangeListener
    virtual void SAL_CALL propertyChange( const css::beans::PropertyChangeEvent& evt ) override;
 
    // XRowSetChangeListener
    virtual void SAL_CALL onRowSetChanged( const css::lang::EventObject& i_Event ) override;
 
// XLoadListener
    virtual void SAL_CALL loaded( const css::lang::EventObject& aEvent ) override;
    virtual void SAL_CALL unloading( const css::lang::EventObject& aEvent ) override;
    virtual void SAL_CALL unloaded( const css::lang::EventObject& aEvent ) override;
    virtual void SAL_CALL reloading( const css::lang::EventObject& aEvent ) override;
    virtual void SAL_CALL reloaded( const css::lang::EventObject& aEvent ) override;
 
protected:
    // XBindableValue
    virtual void SAL_CALL setValueBinding( const css::uno::Reference< css::form::binding::XValueBinding >& _rxBinding ) override;
    virtual css::uno::Reference< css::form::binding::XValueBinding > SAL_CALL getValueBinding(  ) override;
 
    // XModifyListener
    virtual void SAL_CALL modified( const css::lang::EventObject& _rEvent ) override;
 
    // XValidatable
    virtual void SAL_CALL setValidator( const css::uno::Reference< css::form::validation::XValidator >& Validator ) override;
    virtual css::uno::Reference< css::form::validation::XValidator > SAL_CALL getValidator(  ) override;
 
    // XValidityConstraintListener
    virtual void SAL_CALL validityConstraintChanged( const css::lang::EventObject& Source ) override;
 
    // XValidatableFormComponent
    virtual sal_Bool SAL_CALL isValid(  ) override;
    virtual css::uno::Any SAL_CALL getCurrentValue(  ) override;
    virtual void SAL_CALL addFormComponentValidityListener( const css::uno::Reference< css::form::validation::XFormComponentValidityListener >& Listener ) override;
    virtual void SAL_CALL removeFormComponentValidityListener( const css::uno::Reference< css::form::validation::XFormComponentValidityListener >& Listener ) override;
 
protected:
    // OPropertyChangeListener
    virtual void
                _propertyChanged( const css::beans::PropertyChangeEvent& _rEvt ) override;
 
    bool    hasExternalValueBinding() const { return m_xExternalBinding.is(); }
 
    // checks whether we currently have an external validator
    bool    hasValidator() const { return m_xValidator.is(); }
 
    void        transferDbValueToControl( );
 
    void        transferExternalValueToControl( ControlModelLock& _rInstanceLock );
 
    void        transferControlValueToExternal( ControlModelLock& _rInstanceLock );
 
    void        calculateExternalValueType();
 
    const css::uno::Type&
                getExternalValueType() const { return m_aExternalValueType; }
 
    void        initFromField( const css::uno::Reference< css::sdbc::XRowSet>& _rxForm );
 
private:
    void        connectToField( const css::uno::Reference< css::sdbc::XRowSet>& _rxForm );
    void        resetField();
 
    void        recheckValidity( bool _bForceNotification );
 
    void        implInitAggMultiplexer( );
 
    void        implInitValuePropertyListening( ) const;
 
    void        doFormListening( const bool _bStart );
 
    bool isFormListening() const { return m_bFormListening; }
 
    void        impl_determineAmbientForm_nothrow();
 
    void        impl_connectDatabaseColumn_noNotify(
                    bool  _bFromReload
                );
 
    void        impl_disconnectDatabaseColumn_noNotify();
 
    void        connectExternalValueBinding(
                    const css::uno::Reference< css::form::binding::XValueBinding >& _rxBinding,
                    ControlModelLock& _rInstanceLock
                );
 
    void        disconnectExternalValueBinding( );
 
    void        connectValidator(
                    const css::uno::Reference< css::form::validation::XValidator >& _rxValidator
                );
 
    void        disconnectValidator( );
 
    bool    impl_approveValueBinding_nolock(
                    const css::uno::Reference< css::form::binding::XValueBinding >& _rxBinding
                );
};
 
 
    //= inlines
 
    inline void ControlModelLock::acquire()
    {
        m_rModel.lockInstance( OControlModel::LockAccess() );
        m_bLocked = true;
    }
    inline void ControlModelLock::release()
    {
        OSL_ENSURE( m_bLocked, "ControlModelLock::release: not locked!" );
        m_bLocked = false;
 
        if ( 0 == m_rModel.unlockInstance( OControlModel::LockAccess() ) )
            impl_notifyAll_nothrow();
    }
 
 
}
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */