| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _BINDING_HXX |
| #define _BINDING_HXX |
| |
| #include <com/sun/star/uno/Reference.hxx> |
| |
| // forward declaractions |
| namespace xforms |
| { |
| class Model; |
| class EvaluationContext; |
| } |
| namespace com { namespace sun { namespace star { |
| namespace xml { |
| namespace xpath { class XXPathAPI; } |
| namespace dom |
| { |
| class XNode; |
| class XNodeList; |
| } |
| } |
| namespace container { class XNameContainer; } |
| namespace xforms { class XModel; } |
| namespace xsd { class XDataType; } |
| } } } |
| |
| // includes for parent classes |
| #include <cppuhelper/implbase8.hxx> |
| #include <propertysetbase.hxx> |
| #include <com/sun/star/form/binding/XValueBinding.hpp> |
| #include <com/sun/star/form/binding/XListEntrySource.hpp> |
| #include <com/sun/star/form/validation/XValidator.hpp> |
| #include <com/sun/star/util/XModifyBroadcaster.hpp> |
| #include <com/sun/star/container/XNamed.hpp> |
| #include <com/sun/star/xml/dom/events/XEventListener.hpp> |
| #include <com/sun/star/lang/XUnoTunnel.hpp> |
| #include <com/sun/star/util/XCloneable.hpp> |
| |
| // includes for member variables |
| #include "pathexpression.hxx" |
| #include "boolexpression.hxx" |
| #include "mip.hxx" |
| #include <rtl/ustring.hxx> |
| #include <vector> |
| #include <memory> // auto_ptr |
| |
| |
| |
| namespace xforms |
| { |
| |
| /** An XForms Binding. Contains: |
| * # a connection to its model |
| * # an ID |
| * # an binding expression |
| * # model item properties |
| * # (NOT YET IMPLEMENTED) child bindings (sequence of) |
| * |
| * See http://www.w3.org/TR/xforms/ for more information. |
| */ |
| |
| typedef cppu::ImplInheritanceHelper8< |
| PropertySetBase, |
| com::sun::star::form::binding::XValueBinding, |
| com::sun::star::form::binding::XListEntrySource, |
| com::sun::star::form::validation::XValidator, |
| com::sun::star::util::XModifyBroadcaster, |
| com::sun::star::container::XNamed, |
| com::sun::star::xml::dom::events::XEventListener, |
| com::sun::star::lang::XUnoTunnel, |
| com::sun::star::util::XCloneable |
| > Binding_t; |
| |
| class Binding : public Binding_t |
| { |
| public: |
| typedef com::sun::star::uno::Reference<com::sun::star::xforms::XModel> Model_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::util::XModifyListener> XModifyListener_t; |
| typedef std::vector<XModifyListener_t> ModifyListeners_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::form::validation::XValidityConstraintListener> XValidityConstraintListener_t; |
| typedef std::vector<XValidityConstraintListener_t> XValidityConstraintListeners_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::form::binding::XListEntryListener> XListEntryListener_t; |
| typedef std::vector<XListEntryListener_t> XListEntryListeners_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::container::XNameContainer> XNameContainer_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::xml::dom::XNode> XNode_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::xml::dom::XNodeList> XNodeList_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::util::XCloneable> XCloneable_t; |
| typedef com::sun::star::uno::Sequence<sal_Int8> IntSequence_t; |
| typedef com::sun::star::uno::Sequence<rtl::OUString> StringSequence_t; |
| typedef std::vector<MIP> MIPs_t; |
| typedef std::vector<XNode_t> XNodes_t; |
| |
| |
| |
| private: |
| |
| /// the Model to which this Binding belongs; may be NULL |
| Model_t mxModel; |
| |
| /// binding-ID. A document-wide unique ID for this binding element. |
| rtl::OUString msBindingID; |
| |
| /// an XPath-expression to be instantiated on the data instance |
| PathExpression maBindingExpression; |
| |
| /// an XPath-expression to determine read-only status |
| BoolExpression maReadonly; |
| |
| /// an XPath-expression to determine relevance |
| BoolExpression maRelevant; |
| |
| /// an XPath-expression to determine if item is required |
| BoolExpression maRequired; |
| |
| /// an XPath-expression to determine if item is valid |
| BoolExpression maConstraint; |
| |
| /// user-readable explanation of the constraint |
| rtl::OUString msExplainConstraint; |
| |
| /// an XPath-expression to calculate values |
| ComputedExpression maCalculate; |
| |
| /// the XML namespaces used for XML names/XPath-expressions in this binding |
| XNameContainer_t mxNamespaces; |
| |
| /// a type name |
| rtl::OUString msTypeName; |
| |
| /// modify listeners |
| ModifyListeners_t maModifyListeners; |
| |
| /// list entry listener |
| XListEntryListeners_t maListEntryListeners; |
| |
| /// validity listeners; |
| XValidityConstraintListeners_t maValidityListeners; |
| |
| /// nodes on which we are listening for events |
| XNodes_t maEventNodes; |
| |
| /// the current MIP object for the first node we are bound to |
| MIP maMIP; |
| |
| /// flag to detect recursions in calculate |
| bool mbInCalculate; |
| |
| // flags to manage deferred notifications: |
| /// if >0, valueModified() and bindingModified() will only set flags |
| sal_Int32 mnDeferModifyNotifications; |
| bool mbValueModified; /// if true, valueModified needs to be called |
| bool mbBindingModified; /// if true, bindingModified needs to be called |
| |
| |
| void initializePropertySet(); |
| |
| |
| public: |
| Binding(); |
| virtual ~Binding() throw(); |
| |
| // |
| // property methods: get/set value |
| // |
| |
| Model_t getModel() const; /// get XForms model |
| void _setModel( const Model_t& ); /// set XForms model (only called by Model) |
| |
| |
| rtl::OUString getModelID() const; /// get ID of XForms model |
| |
| rtl::OUString getBindingID() const; /// get ID for this binding |
| void setBindingID( const rtl::OUString& ); /// set ID for this binding |
| |
| rtl::OUString getBindingExpression() const; /// get binding expression |
| void setBindingExpression( const rtl::OUString& ); /// set binding exp. |
| |
| // MIPs (model item properties) |
| |
| rtl::OUString getReadonlyExpression() const; /// get read-only MIP |
| void setReadonlyExpression( const rtl::OUString& ); /// set read-only MIP |
| |
| rtl::OUString getRelevantExpression() const; /// get relevant MIP |
| void setRelevantExpression( const rtl::OUString& ); /// set relevant MIP |
| |
| rtl::OUString getRequiredExpression() const; /// get required MIP |
| void setRequiredExpression( const rtl::OUString& ); /// set required MIP |
| |
| rtl::OUString getConstraintExpression() const; /// get constraint MIP |
| void setConstraintExpression( const rtl::OUString& );/// set constraint MIP |
| |
| rtl::OUString getCalculateExpression() const; /// get calculate MIP |
| void setCalculateExpression( const rtl::OUString& ); /// set calculate MIP |
| |
| rtl::OUString getType() const; /// get type name MIP (static) |
| void setType( const rtl::OUString& ); /// set type name MIP (static) |
| |
| // a binding expression can only be interpreted with respect to |
| // suitable namespace declarations. We collect those in the model and in a binding. |
| |
| // access to a binding's namespace |
| // (set-method only changes local namespaces (but may add to model)) |
| XNameContainer_t getBindingNamespaces() const; /// set binding namespaces |
| void setBindingNamespaces( const XNameContainer_t& ); /// get binding nmsp. |
| |
| // access to the model's namespaces |
| // (set-method changes model's namespaces (unless a local one is present)) |
| XNameContainer_t getModelNamespaces() const; /// set model namespaces |
| void setModelNamespaces( const XNameContainer_t& ); /// get model nmsp. |
| |
| |
| // read-only properties that map MIPs to control data source properties |
| bool getReadOnly() const; // MIP readonly |
| bool getRelevant() const; // MIP relevant |
| bool getExternalData() const; // mapped from model's ExternalData property |
| |
| |
| // missing binding properties: |
| // - type (static; default: xsd:string) |
| // - minOccurs/maxOccurs (computed XPath; default: 0/inf) |
| // - p3ptype (static; no default) |
| |
| |
| |
| |
| /// get this binding's context node |
| xforms::EvaluationContext getEvaluationContext() const; |
| |
| /// get evalation contexts for this binding's MIPs |
| std::vector<xforms::EvaluationContext> getMIPEvaluationContexts(); |
| |
| /// get nodeset the bind is bound to |
| XNodeList_t getXNodeList(); |
| |
| /// heuristically determine whether this binding is simple binding |
| /// (here: simple binding == does not depend on other parts of the |
| /// instance, it's not a 'dynamic' binding) |
| bool isSimpleBinding() const; |
| |
| /// heuristically determine whether this binding's binding |
| /// expression is simple |
| bool isSimpleBindingExpression() const; |
| |
| /// update this binding (e.g. called by model for refresh ) |
| void update(); |
| |
| /// prevent change notifications being sent to controls |
| void deferNotifications( bool ); |
| |
| /// is this binding valid? (are constraint, type and required MIPs ok?) |
| bool isValid(); |
| |
| /// determine whether this binding currently performs a useful |
| /// function, r whether is may be discarded |
| bool isUseful(); |
| |
| /// explain why binding is invalid |
| rtl::OUString explainInvalid(); |
| |
| |
| // the ID for XUnoTunnel calls |
| static IntSequence_t getUnoTunnelID(); |
| static Binding* getBinding( const com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet>& ); |
| |
| // |
| // class-scoped typedef for easy-to-read UNO interfaces |
| // |
| |
| // basic types |
| typedef com::sun::star::uno::Any Any_t; |
| typedef com::sun::star::uno::Sequence<com::sun::star::uno::Type> Sequence_Type_t; |
| typedef com::sun::star::uno::Type Type_t; |
| |
| // reference types |
| typedef com::sun::star::uno::Reference<com::sun::star::beans::XPropertyChangeListener> XPropertyChangeListener_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::beans::XPropertySetInfo> XPropertySetInfo_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::beans::XVetoableChangeListener> XVetoableChangeListener_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::xml::xpath::XXPathAPI> XXPathAPI_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::xml::dom::events::XEvent> XEvent_t; |
| typedef com::sun::star::uno::Reference<com::sun::star::xsd::XDataType> XDataType_t; |
| |
| // exceptions |
| typedef com::sun::star::beans::PropertyVetoException PropertyVetoException_t; |
| typedef com::sun::star::beans::UnknownPropertyException UnknownPropertyException_t; |
| typedef com::sun::star::lang::IllegalArgumentException IllegalArgumentException_t; |
| typedef com::sun::star::lang::NoSupportException NoSupportException_t; |
| typedef com::sun::star::lang::WrappedTargetException WrappedTargetException_t; |
| typedef com::sun::star::uno::RuntimeException RuntimeException_t; |
| typedef com::sun::star::form::binding::IncompatibleTypesException IncompatibleTypesException_t; |
| typedef com::sun::star::form::binding::InvalidBindingStateException InvalidBindingStateException_t; |
| typedef com::sun::star::lang::NullPointerException NullPointerException_t; |
| typedef com::sun::star::lang::IndexOutOfBoundsException IndexOutOfBoundsException_t; |
| |
| |
| |
| private: |
| /// check whether object is live, and throw suitable exception if not |
| /// (to be used be API methods before acting on the object) |
| void checkLive() throw( RuntimeException_t ); |
| |
| /// check whether binding has a model, and throw exception if not |
| /// (to be used be API methods before acting on the object) |
| void checkModel() throw( RuntimeException_t ); |
| |
| /// determine whether object is live |
| /// live: has model, and model has been initialized |
| bool isLive() const; |
| |
| /// get the model implementation |
| xforms::Model* getModelImpl() const; |
| xforms::Model* getModelImpl( const Model_t& xModel ) const; |
| |
| /// get MIP evaluation contexts |
| /// (only valid if control has already been bound) |
| std::vector<xforms::EvaluationContext> _getMIPEvaluationContexts() const; |
| |
| /// bind this binding, and pre-compute the affected nodes |
| void bind( bool bForceRebind = false ); |
| |
| /// the binding value has been changed: |
| /// trigger a modified event on all modified listeners |
| void valueModified(); |
| |
| /// the binding itself has changed: |
| /// force rebind, then call valueModified() |
| void bindingModified(); |
| |
| |
| /// register the event listeners for |
| void registerListeners(); |
| |
| /// set MIPs defined by this binding on MIP item |
| MIP getLocalMIP() const; |
| |
| /// get the data type that applies to this binding |
| XDataType_t getDataType(); |
| |
| /// determine whether binding is valid according to the given data type |
| bool isValid_DataType(); |
| |
| /// explain validity of binding with respect to the given data type |
| rtl::OUString explainInvalid_DataType(); |
| |
| /// 'clear' this binding - remove all listeners, etc. |
| void clear(); |
| |
| /// distribute MIPs from current node recursively to childs |
| void distributeMIP( const XNode_t &rxNode ); |
| |
| /// implement get*Namespaces() |
| XNameContainer_t _getNamespaces() const; |
| |
| /// implement set*Namespaces() |
| void _setNamespaces( const XNameContainer_t&, bool bBinding ); |
| |
| /// set a useful default binding ID (if none is set) |
| void _checkBindingID(); |
| |
| public: |
| /// for debugging purposes only: get the MIPs defined by this binding |
| const MIP* _getMIP(); |
| |
| |
| |
| |
| |
| // |
| // XValueBinding: |
| // |
| |
| public: |
| |
| virtual Sequence_Type_t SAL_CALL getSupportedValueTypes() |
| throw( RuntimeException_t ); |
| |
| virtual sal_Bool SAL_CALL supportsType( const Type_t& aType ) |
| throw( RuntimeException_t ); |
| |
| virtual Any_t SAL_CALL getValue( const Type_t& aType ) |
| throw( IncompatibleTypesException_t, |
| RuntimeException_t ); |
| |
| virtual void SAL_CALL setValue( const Any_t& aValue ) |
| throw( IncompatibleTypesException_t, |
| InvalidBindingStateException_t, |
| NoSupportException_t, |
| RuntimeException_t ); |
| |
| |
| |
| // |
| // XListEntry Source |
| // |
| |
| virtual sal_Int32 SAL_CALL getListEntryCount() |
| throw( RuntimeException_t ); |
| |
| virtual rtl::OUString SAL_CALL getListEntry( sal_Int32 nPosition ) |
| throw( IndexOutOfBoundsException_t, |
| RuntimeException_t ); |
| |
| virtual StringSequence_t SAL_CALL getAllListEntries() |
| throw( RuntimeException_t ); |
| |
| virtual void SAL_CALL addListEntryListener( const XListEntryListener_t& ) |
| throw( NullPointerException_t, |
| RuntimeException_t ); |
| |
| virtual void SAL_CALL removeListEntryListener( const XListEntryListener_t&) |
| throw( NullPointerException_t, |
| RuntimeException_t ); |
| |
| |
| |
| // |
| // XValidator: |
| // |
| |
| virtual sal_Bool SAL_CALL isValid( |
| const Any_t& ) |
| throw( RuntimeException_t ); |
| |
| virtual rtl::OUString SAL_CALL explainInvalid( |
| const Any_t& ) |
| throw( RuntimeException_t ); |
| |
| virtual void SAL_CALL addValidityConstraintListener( |
| const XValidityConstraintListener_t& xListener ) |
| throw( NullPointerException_t, |
| RuntimeException_t ); |
| |
| virtual void SAL_CALL removeValidityConstraintListener( |
| const XValidityConstraintListener_t& xListener ) |
| throw( NullPointerException_t, |
| RuntimeException_t ); |
| |
| |
| // |
| // XModifyBroadcaster & friends: |
| // inform listeners about changes in our values |
| // |
| |
| public: |
| |
| virtual void SAL_CALL addModifyListener( |
| const XModifyListener_t& xListener ) |
| throw( RuntimeException_t ); |
| |
| virtual void SAL_CALL removeModifyListener( |
| const XModifyListener_t& xListener ) |
| throw( RuntimeException_t ); |
| |
| |
| |
| |
| // |
| // XNamed: |
| // get/set name |
| // |
| |
| public: |
| |
| virtual rtl::OUString SAL_CALL getName() |
| throw( RuntimeException_t ); |
| |
| virtual void SAL_CALL setName( const rtl::OUString& ) |
| throw( RuntimeException_t ); |
| |
| |
| |
| // |
| // xml::dom::event::XEventListener |
| // receive an event if our node changed |
| // |
| |
| virtual void SAL_CALL handleEvent( |
| const XEvent_t& xEvent ) |
| throw( RuntimeException_t ); |
| |
| |
| |
| // |
| // XUnoTunnel |
| // |
| |
| virtual sal_Int64 SAL_CALL getSomething( const IntSequence_t& ) |
| throw( RuntimeException_t ); |
| |
| |
| // |
| // XCloneable |
| // |
| |
| virtual XCloneable_t SAL_CALL createClone() |
| throw( RuntimeException_t ); |
| }; |
| |
| |
| } // namespace xforms |
| |
| #endif |