/* -*- 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace frm { // default tab index for components const sal_Int16 FRM_DEFAULT_TABINDEX = 0; class OControlModel; //= ControlModelLock /** class whose instances lock an OControlModel Locking here merely means locking the OControlModel's mutex. In addition to the locking facility, the class is also able to fire property change notifications. This happens when the last ControlModelLock instance on a stack dies. */ 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; }; /** adds a property change notification, which is to be fired when the last lock on the model (in the current thread) is released. */ 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: /** constructs a control @param _rFactory the service factory for this control @param _rAggregateService the service name of the component to aggregate @param _bSetDelegator set this to if you don't want the constructor to set the delegator at the aggregate. In this case, you have to call doSetDelegator within your own constructor. This is helpful, if your derived class wants to cache an interface of the aggregate. In this case, the aggregate needs to be queried for this interface before the XAggregation::setDelegator call. In such a case, pass to this parameter. Then, cache the aggregate's interface(s) as needed. Afterwards, call doSetDelegator. In your destructor, you need to call doResetDelegator before resetting the cached interfaces. This will reset the aggregates delegator to , which will ensure that the XInterface::release calls on the cached interfaces are really applied to the aggregate, instead of the OControl itself. */ OControl( const css::uno::Reference< css::uno::XComponentContext >& _rFactory, const OUString& _rAggregateService, const bool _bSetDelegator = true ); protected: virtual ~OControl() override; /** sets the control as delegator at the aggregate This has to be called from within your derived class' constructor, if and only if you passed to the _bSetDelegator parameter of the OControl constructor. */ 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_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 SAL_CALL getSupportedServiceNames() override; virtual OUString SAL_CALL getImplementationName() override = 0; // XControl virtual void SAL_CALL setContext(const css::uno::Reference& Context) override; virtual css::uno::Reference SAL_CALL getContext() override; virtual void SAL_CALL createPeer(const css::uno::Reference& Toolkit, const css::uno::Reference& Parent) override; virtual css::uno::Reference SAL_CALL getPeer() override; virtual sal_Bool SAL_CALL setModel(const css::uno::Reference& Model) override; virtual css::uno::Reference SAL_CALL getModel() override; virtual css::uno::Reference 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 m_xContext; ::osl::Mutex m_aMutex; oslInterlockedCount m_lockCount; css::uno::Reference m_xParent; // ParentComponent PropertyBagHelper m_aPropertyBagHelper; const css::uno::Reference& getContext() const { return m_xContext; } // 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_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 // 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; /** to be called after an OBoundControlModel (a derivee, respectively) has been cloned

This method contains late initializations which cannot be done in the constructor of this base class, since the virtual method of derived classes do not yet work there.

*/ 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_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 SAL_CALL getSupportedServiceNames() override; virtual OUString SAL_CALL getImplementationName() override = 0; // XServiceInfo - static version(s) /// @throws css::uno::RuntimeException static css::uno::Sequence 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 SAL_CALL getParent() override; virtual void SAL_CALL setParent(const css::uno::Reference& 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; /** describes the properties provided by this class, or its respective derived class Derived classes usually call the base class first, and then append own properties. */ 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; /** describes the properties of our aggregate The default implementation simply asks m_xAggregateSet for its properties. You usually only need to override this method if you want to filter the aggregate properties. */ 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 m_aUpdateListeners; ::comphelper::OInterfaceContainerHelper3 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; // 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; // 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; /// late ctor after cloning virtual void clonedFrom( const OControlModel* _pOriginal ) override; /** initializes the part of the class which is related to the control value.

Kind of late ctor, to be called for derivees which have a dedicated value property.
The value property is the property which's value is synced with either the database column the object is bound to, or with the external value binding, if present.
E.g. for a text control model, this property will most probably be "Text".

Derived classes are strongly recommended to call this method - at least the "DataFieldProperty" (exposed in getFastPropertyValue) relies on the information given herein, and needs to be supplied otherwise else.

If this method has been called properly, then setControlValue does not need to be overridden - it will simply set the property value at the aggregate then.

@precond The method has not be called before during the life time of the object. @param _rValuePropertyName the name of the value property @param _nValuePropertyExternalHandle the handle of the property, as exposed to external components.
Normally, this information can be obtained dynamically (e.g. from describeFixedProperties), but since this method is to be called from within the constructor of derived classes, we prefer to be on the *really* safe side here... @see setControlValue @see suspendValueListening @see resumeValueListening @see describeFixedProperties */ void initValueProperty( const OUString& _rValuePropertyName, sal_Int32 _nValuePropertyExternalHandle ); /** initializes the part of the class which is related to the control value.

In opposite to ->initValueProperty, this method is to be used for value properties which are not implemented by our aggregate, but by ourselves.

Certain functionality is not available when using own value properties. This includes binding to an external value and external validation. (This is not a conceptual limit, but simply missing implementation.)

*/ void initOwnValueProperty( const OUString& i_rValuePropertyName ); /** suspends listening at the value property

As long as this listening is suspended, changes in the value property will not be recognized and not be handled.

@see initValueProperty @see resumeValueListening */ void suspendValueListening( ); /** resumes listening at the value property

As long as this listening is suspended, changes in the value property will not be recognized and not be handled.

@precond listening at the value property is currently suspended @see initValueProperty @see resumeValueListening */ void resumeValueListening( ); /** (to be) called when the value property changed Normally, this is done automatically, since the value property is a property of our aggregate, and we're a listener at this property. However, in some cases the value property might not be an aggregate property, but a property of the delegator instance. In this case, you'll need to call onValuePropertyChange whenever this property changes. */ void onValuePropertyChange( ControlModelLock& i_rControLock ); /** starts listening at the aggregate, for changes in the given property

The OBoundControlModel automatically registers a multiplexer which listens for changes in the aggregate property values. By default, only the control value property is observed. You may add additional properties to be observed with this method.

@see initValueProperty @see _propertyChanged */ void startAggregatePropertyListening( const OUString& _rPropertyName ); /** returns the default which should be used when resetting the control

The default implementation returns an empty Any.

@see resetNoBroadcast */ virtual css::uno::Any getDefaultForReset() const; /** translates a db column value into a control value.

Must transform the very current value of the database column we're bound to (m_xColumn) into a value which can be used as current value for the control.

@see setControlValue @pure */ virtual css::uno::Any translateDbColumnToControlValue( ) = 0; /** returns the data types which the control could use to exchange data with an external value binding The types returned here are completely independent from the concrete value binding, they're just candidates which depend on the control type, and possible the concrete state of the control (i.e. some property value). If a control implementation supports multiple types, the ordering in the returned sequence indicates preference: Preferred types are mentioned first. The default implementation returns the type of our value property. */ virtual css::uno::Sequence< css::uno::Type > getSupportedBindingTypes(); /** translates the given value, which was obtained from the current external value binding, to a value which can be used in setControlValue

The default implementation returns the value itself, exception when it is VOID, and our value property is not allowed to be void - in this case, the returned value is a default-constructed value of the type required by our value property. @see hasExternalValueBinding @see getExternalValueType */ virtual css::uno::Any translateExternalValueToControlValue( const css::uno::Any& _rExternalValue ) const; /** commits the current control value to our external value binding

The default implementation simply calls getControlValue.

@see hasExternalValueBinding @see initValueProperty */ virtual css::uno::Any translateControlValueToExternalValue( ) const; /** commits the current control value to the database column we're bound to @precond we're properly bound to a database column, especially m_xColumnUpdate is not @param _bPostReset if and only if the current control value results from a reset (getDefaultForReset) @pure */ virtual bool commitControlValueToDbColumn( bool _bPostReset ) = 0; /** sets the given value as new current value for the control Besides some administrative work (such as caring for m_eControlValueChangeInstigator), this method simply calls doSetControlValue. @precond Our own mutex is locked. @param _rValue The value to set. This value is guaranteed to be created by translateDbColumnToControlValue or translateExternalValueToControlValue @param _eInstigator the instigator of the value change */ void setControlValue( const css::uno::Any& _rValue, ValueChangeInstigator _eInstigator ); /**

The default implementation will forward the given value to the aggregate, using m_nValuePropertyAggregateHandle and/or m_sValuePropertyName.

@precond Our own mutex is locked. @param _rValue The value to set. This value is guaranteed to be created by translateDbColumnToControlValue or translateExternalValueToControlValue */ virtual void doSetControlValue( const css::uno::Any& _rValue ); /** retrieves the current value of the control

The default implementation will ask the aggregate for the property value determined by either m_nValuePropertyAggregateHandle and/or m_sValuePropertyName.

@precond Our own mutex is locked. */ virtual css::uno::Any getControlValue( ) const; /** called whenever a connection to a database column has been established */ virtual void onConnectedDbColumn( const css::uno::Reference< css::uno::XInterface >& _rxForm ); /** called whenever a connection to a database column has been suspended */ virtual void onDisconnectedDbColumn(); /** called whenever a connection to an external supplier of values (XValueBinding) has been established @see m_xExternalBinding */ virtual void onConnectedExternalValue( ); /** called whenever an external validator has been registered */ void onConnectedValidator( ); /** called whenever an external validator has been revoked */ void onDisconnectedValidator( ); /** nFieldType is the type of the field, on which the model will be linked. The linking happens when sal_True is returned. The default-implementation allows everything but the three binary types and FieldType_OTHER. */ virtual bool approveDbColumnType(sal_Int32 _nColumnType); /** retrieves the current value of the control, in a shape which can be used with our external validator. The default implementation simply calls >translateControlValueToExternalValue. @precond Our own mutex is locked. */ virtual css::uno::Any translateControlValueToValidatableValue( ) const; /** retrieves the current value of the form component This is the implementation method for XValidatableFormComponent::getCurrentValue. The default implementation calls translateControlValueToValidatableValue if a validator is present, otherwise getControlValue. @precond our mutex is locked when this method is called */ virtual css::uno::Any getCurrentFormComponentValue() const; /** We can't write (new) common properties in this base class, as the file format doesn't allow this (unfortunately). So derived classes may use the following two methods. They secure the written data with marks, so any new common properties in newer versions will be skipped by older ones. */ 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(); /** called to reset the control to some kind of default.

The semantics of "default" is finally defined by the derived class (in particular, by getDefaultForReset).

No listener notification needs to be done in the derived class.

Normally, you won't override this method, but getDefaultForReset instead.

@see getDefaultForReset */ virtual void resetNoBroadcast(); virtual css::uno::Sequence< css::uno::Type> _getTypes() override; /// sets m_xField to the given new value, without notifying our listeners 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 SAL_CALL getSupportedServiceNames( ) override; // XServiceInfo - static version /// @throws css::uno::RuntimeException static css::uno::Sequence 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; /// checks whether we currently have an external value binding in place bool hasExternalValueBinding() const { return m_xExternalBinding.is(); } // checks whether we currently have an external validator bool hasValidator() const { return m_xValidator.is(); } /** transfers the very current value of the db column we're bound to the control @precond our own mutex is locked @precond we don't have an external binding in place */ void transferDbValueToControl( ); /** transfers the current value of the active external binding to the control @precond we do have an active external binding in place */ void transferExternalValueToControl( ControlModelLock& _rInstanceLock ); /** transfers the control value to the external binding @precond our own mutex is locked, and _rInstanceLock is the guard locking it @precond we do have an active external binding in place */ void transferControlValueToExternal( ControlModelLock& _rInstanceLock ); /** calculates the type which is to be used to communicate with the current external binding, and stores it in m_aExternalValueType The method checks the possible type candidates as returned by getSupportedBindingTypes, and the types supported by the current external binding, if any. */ void calculateExternalValueType(); /** returns the type which should be used to exchange data with our external value binding @see initValueProperty */ const css::uno::Type& getExternalValueType() const { return m_aExternalValueType; } /** initializes the control from m_xField Basically, this method calls transferDbValueToControl - but only if our cursor is positioned on a valid row. Otherwise, the control is reset. @precond m_xField is not */ void initFromField( const css::uno::Reference< css::sdbc::XRowSet>& _rxForm ); private: void connectToField( const css::uno::Reference< css::sdbc::XRowSet>& _rxForm ); void resetField(); /** does a new validation of the control value If necessary, our m_bIsCurrentValueValid member will be adjusted, and changes will be notified. Note that it's not necessary that we're connected to a validator. If we are not, it's assumed that our value is valid, and this is handled appropriately. Use this method if there is a potential that only the validity flag changed. If any of the other aspects (our current value, or our current text) changed, then pass for _bForceNotification. @param _bForceNotification if , then the validity listeners will be notified, not matter whether the validity changed. */ void recheckValidity( bool _bForceNotification ); /// initializes m_pAggPropMultiplexer void implInitAggMultiplexer( ); /// initializes listening at the value property void implInitValuePropertyListening( ) const; /** adds or removes the component as load listener to/from our form, and (if necessary) as RowSetChange listener at our parent. @precond there must no external value binding be in place */ void doFormListening( const bool _bStart ); bool isFormListening() const { return m_bFormListening; } /** determines the new value of m_xAmbientForm */ void impl_determineAmbientForm_nothrow(); /** connects to a value supplier which is a database column. The column is taken from our parent, which must be a database form respectively row set. @precond The control does not have an external value supplier @param _bFromReload Determines whether the connection is made after the row set has been loaded () or reloaded () @see impl_disconnectDatabaseColumn_noNotify */ void impl_connectDatabaseColumn_noNotify( bool _bFromReload ); /** disconnects from a value supplier which is a database column @precond The control does not have an external value supplier @see impl_connectDatabaseColumn_noNotify */ void impl_disconnectDatabaseColumn_noNotify(); /** connects to an external value binding

Note that by definition, external data bindings supersede the SQL data binding which is defined by our RowSet-column-related properties. This means that in case we're currently connected to a database column when this is called, this connection is suspended.

@precond the new external binding has already been approved (see impl_approveValueBinding_nolock) @precond there currently is no external binding in place */ void connectExternalValueBinding( const css::uno::Reference< css::form::binding::XValueBinding >& _rxBinding, ControlModelLock& _rInstanceLock ); /** disconnects from an external value binding @precond there currently is an external binding in place */ void disconnectExternalValueBinding( ); /** connects the component to an external validator @precond there currently is no active validator @precond our mutex is currently locked exactly once */ void connectValidator( const css::uno::Reference< css::form::validation::XValidator >& _rxValidator ); /** disconnects the component from its current an external validator @precond there currently is an active validator @precond our mutex is currently locked exactly once */ void disconnectValidator( ); /** called from within XBindableValue::setValueBinding to approve the new binding The default implementation approves the binding if and only if it is not , and supports the type returned by getExternalValueType. @param _rxBinding the binding which applies for being responsible for our value, Must not be @return if and only if the given binding can supply values in the proper type @seealso getExternalValueType */ 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: */