summaryrefslogtreecommitdiffstats
path: root/forms/source/xforms/binding.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /forms/source/xforms/binding.hxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'forms/source/xforms/binding.hxx')
-rw-r--r--forms/source/xforms/binding.hxx407
1 files changed, 407 insertions, 0 deletions
diff --git a/forms/source/xforms/binding.hxx b/forms/source/xforms/binding.hxx
new file mode 100644
index 000000000..d7201a5b5
--- /dev/null
+++ b/forms/source/xforms/binding.hxx
@@ -0,0 +1,407 @@
+/* -*- 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 <com/sun/star/uno/Reference.hxx>
+#include <cppuhelper/implbase.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>
+
+#include "pathexpression.hxx"
+#include "boolexpression.hxx"
+#include "mip.hxx"
+#include <rtl/ustring.hxx>
+#include <vector>
+
+// forward declaractions
+namespace xforms
+{
+ class Model;
+ class EvaluationContext;
+}
+namespace com::sun::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; }
+}
+
+
+namespace xforms
+{
+
+/** An XForms Binding. Contains:
+ * # a connection to its model
+ * # an ID
+ * # a binding expression
+ * # model item properties
+ * # (NOT YET IMPLEMENTED) child bindings (sequence of)
+ *
+ * See http://www.w3.org/TR/xforms/ for more information.
+ */
+
+typedef cppu::ImplInheritanceHelper<
+ PropertySetBase,
+ css::form::binding::XValueBinding,
+ css::form::binding::XListEntrySource,
+ css::form::validation::XValidator,
+ css::util::XModifyBroadcaster,
+ css::container::XNamed,
+ css::xml::dom::events::XEventListener,
+ css::lang::XUnoTunnel,
+ css::util::XCloneable
+> Binding_t;
+
+class Binding : public Binding_t
+{
+public:
+ typedef std::vector<css::uno::Reference<css::util::XModifyListener> > ModifyListeners_t;
+ typedef std::vector<css::uno::Reference<css::form::validation::XValidityConstraintListener> > XValidityConstraintListeners_t;
+ typedef std::vector<css::uno::Reference<css::form::binding::XListEntryListener> > XListEntryListeners_t;
+
+
+private:
+
+ /// the Model to which this Binding belongs; may be NULL
+ css::uno::Reference<css::xforms::XModel> mxModel;
+
+ /// binding-ID. A document-wide unique ID for this binding element.
+ 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
+ OUString msExplainConstraint;
+
+ /// an XPath-expression to calculate values
+ ComputedExpression maCalculate;
+
+ /// the XML namespaces used for XML names/XPath-expressions in this binding
+ css::uno::Reference<css::container::XNameContainer> mxNamespaces;
+
+ /// a type name
+ 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
+ std::vector<css::uno::Reference<css::xml::dom::XNode> > 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() override;
+
+
+ // property methods: get/set value
+
+
+ css::uno::Reference<css::xforms::XModel> getModel() const { return mxModel;} /// get XForms model
+ void _setModel( const css::uno::Reference<css::xforms::XModel>& ); /// set XForms model (only called by Model)
+
+
+ OUString getModelID() const; /// get ID of XForms model
+
+ OUString getBindingID() const { return msBindingID;} /// get ID for this binding
+ void setBindingID( const OUString& ); /// set ID for this binding
+
+ OUString getBindingExpression() const; /// get binding expression
+ void setBindingExpression( const OUString& ); /// set binding exp.
+
+ // MIPs (model item properties)
+
+ OUString getReadonlyExpression() const; /// get read-only MIP
+ void setReadonlyExpression( const OUString& ); /// set read-only MIP
+
+ OUString getRelevantExpression() const; /// get relevant MIP
+ void setRelevantExpression( const OUString& ); /// set relevant MIP
+
+ OUString getRequiredExpression() const; /// get required MIP
+ void setRequiredExpression( const OUString& ); /// set required MIP
+
+ OUString getConstraintExpression() const; /// get constraint MIP
+ void setConstraintExpression( const OUString& );/// set constraint MIP
+
+ OUString getCalculateExpression() const; /// get calculate MIP
+ void setCalculateExpression( const OUString& ); /// set calculate MIP
+
+ OUString getType() const { return msTypeName;} /// get type name MIP (static)
+ void setType( const 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))
+ css::uno::Reference<css::container::XNameContainer> getBindingNamespaces() const { return mxNamespaces; }
+ void setBindingNamespaces( const css::uno::Reference<css::container::XNameContainer>& ); /// get binding nmsp.
+
+ // access to the model's namespaces
+ // (set-method changes model's namespaces (unless a local one is present))
+ css::uno::Reference<css::container::XNameContainer> getModelNamespaces() const; /// set model namespaces
+ void setModelNamespaces( const css::uno::Reference<css::container::XNameContainer>& ); /// 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 evaluation contexts for this binding's MIPs
+ std::vector<xforms::EvaluationContext> getMIPEvaluationContexts();
+
+ /// get nodeset the bind is bound to
+ css::uno::Reference<css::xml::dom::XNodeList> 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() const;
+
+ /// determine whether this binding currently performs a useful
+ /// function, r whether is may be discarded
+ bool isUseful() const;
+
+ /// explain why binding is invalid
+ OUString explainInvalid();
+
+
+ // the ID for XUnoTunnel calls
+ static css::uno::Sequence<sal_Int8> getUnoTunnelId();
+
+
+private:
+ /// check whether object is live, and throw suitable exception if not
+ /// (to be used be API methods before acting on the object)
+ ///
+ /// @throws css::uno::RuntimeException
+ void checkLive();
+
+ /// determine whether object is live
+ /// live: has model, and model has been initialized
+ bool isLive() const;
+
+ /// get the model implementation
+ xforms::Model* getModelImpl() 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();
+
+
+ /// set MIPs defined by this binding on MIP item
+ MIP getLocalMIP() const;
+
+ /// get the data type that applies to this binding
+ css::uno::Reference<css::xsd::XDataType> getDataType() const;
+
+ /// determine whether binding is valid according to the given data type
+ bool isValid_DataType() const;
+
+ /// explain validity of binding with respect to the given data type
+ OUString explainInvalid_DataType();
+
+ /// 'clear' this binding - remove all listeners, etc.
+ void clear();
+
+ /// distribute MIPs from current node recursively to children
+ void distributeMIP( const css::uno::Reference<css::xml::dom::XNode> &rxNode );
+
+ /// implement get*Namespaces()
+ css::uno::Reference<css::container::XNameContainer> _getNamespaces() const;
+
+ /// implement set*Namespaces()
+ void _setNamespaces( const css::uno::Reference<css::container::XNameContainer>&, bool bBinding );
+
+ /// set a useful default binding ID (if none is set)
+ void _checkBindingID();
+
+public:
+
+ virtual css::uno::Sequence<css::uno::Type> SAL_CALL getSupportedValueTypes() override;
+
+ virtual sal_Bool SAL_CALL supportsType( const css::uno::Type& aType ) override;
+
+ virtual css::uno::Any SAL_CALL getValue( const css::uno::Type& aType ) override;
+
+ virtual void SAL_CALL setValue( const css::uno::Any& aValue ) override;
+
+
+ // XListEntrySource
+
+
+ virtual sal_Int32 SAL_CALL getListEntryCount() override;
+
+ virtual OUString SAL_CALL getListEntry( sal_Int32 nPosition ) override;
+
+ virtual css::uno::Sequence<OUString> SAL_CALL getAllListEntries() override;
+
+ virtual void SAL_CALL addListEntryListener( const css::uno::Reference<css::form::binding::XListEntryListener>& ) override;
+
+ virtual void SAL_CALL removeListEntryListener( const css::uno::Reference<css::form::binding::XListEntryListener>&) override;
+
+
+ // XValidator:
+
+
+ virtual sal_Bool SAL_CALL isValid(
+ const css::uno::Any& ) override;
+
+ virtual OUString SAL_CALL explainInvalid(
+ const css::uno::Any& ) override;
+
+ virtual void SAL_CALL addValidityConstraintListener(
+ const css::uno::Reference<css::form::validation::XValidityConstraintListener>& xListener ) override;
+
+ virtual void SAL_CALL removeValidityConstraintListener(
+ const css::uno::Reference<css::form::validation::XValidityConstraintListener>& xListener ) override;
+
+
+ // XModifyBroadcaster & friends:
+ // inform listeners about changes in our values
+
+
+public:
+
+ virtual void SAL_CALL addModifyListener(
+ const css::uno::Reference<css::util::XModifyListener>& xListener ) override;
+
+ virtual void SAL_CALL removeModifyListener(
+ const css::uno::Reference<css::util::XModifyListener>& xListener ) override;
+
+
+ // XNamed:
+ // get/set name
+
+
+public:
+
+ virtual OUString SAL_CALL getName() override;
+
+ virtual void SAL_CALL setName( const OUString& ) override;
+
+
+ // xml::dom::event::XEventListener
+ // receive an event if our node changed
+
+
+ virtual void SAL_CALL handleEvent(
+ const css::uno::Reference<css::xml::dom::events::XEvent>& xEvent ) override;
+
+
+ // XUnoTunnel
+
+
+ virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence<sal_Int8>& ) override;
+
+
+ // XCloneable
+
+
+ virtual css::uno::Reference<css::util::XCloneable> SAL_CALL createClone() override;
+};
+
+
+} // namespace xforms
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */