binding.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 <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
{
 
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:
 
    css::uno::Reference<css::xforms::XModel> mxModel;
 
    OUString msBindingID;
 
    PathExpression maBindingExpression;
 
    BoolExpression maReadonly;
 
    BoolExpression maRelevant;
 
    BoolExpression maRequired;
 
    BoolExpression maConstraint;
 
    OUString msExplainConstraint;
 
    ComputedExpression maCalculate;
 
    css::uno::Reference<css::container::XNameContainer> mxNamespaces;
 
    OUString msTypeName;
 
    ModifyListeners_t maModifyListeners;
 
    XListEntryListeners_t maListEntryListeners;
 
    XValidityConstraintListeners_t maValidityListeners;
 
    std::vector<css::uno::Reference<css::xml::dom::XNode> > maEventNodes;
 
    MIP maMIP;
 
    bool mbInCalculate;
 
    // flags to manage deferred notifications:
    sal_Int32 mnDeferModifyNotifications;
    bool mbValueModified;   
    bool mbBindingModified; 
 
 
    void initializePropertySet();
 
 
public:
    Binding();
    virtual ~Binding() override;
 
 
    // property methods: get/set value
 
 
    css::uno::Reference<css::xforms::XModel> getModel() const { return mxModel;}   
    void _setModel( const css::uno::Reference<css::xforms::XModel>& ); 
 
 
    OUString getModelID() const;   
 
    OUString getBindingID() const { return msBindingID;}         
    void setBindingID( const OUString& );  
 
    OUString getBindingExpression() const; 
    void setBindingExpression( const OUString& );  
 
    // MIPs (model item properties)
 
    OUString getReadonlyExpression() const;         
    void setReadonlyExpression( const OUString& );  
 
    OUString getRelevantExpression() const;         
    void setRelevantExpression( const OUString& );  
 
    OUString getRequiredExpression() const;         
    void setRequiredExpression( const OUString& );  
 
    OUString getConstraintExpression() const;       
    void setConstraintExpression( const OUString& );
 
    OUString getCalculateExpression() const;        
    void setCalculateExpression( const OUString& ); 
 
    OUString getType() const { return msTypeName;}         
    void setType( const OUString& );  
 
    // 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>& ); 
 
    // 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;  
    void setModelNamespaces( const css::uno::Reference<css::container::XNameContainer>& ); 
 
 
    // 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)
 
 
    xforms::EvaluationContext getEvaluationContext() const;
 
    std::vector<xforms::EvaluationContext> getMIPEvaluationContexts();
 
    css::uno::Reference<css::xml::dom::XNodeList> getXNodeList();
 
    bool isSimpleBinding() const;
 
    bool isSimpleBindingExpression() const;
 
    void update();
 
    void deferNotifications( bool );
 
    bool isValid() const;
 
    bool isUseful() const;
 
    OUString explainInvalid();
 
 
    // the ID for XUnoTunnel calls
    static css::uno::Sequence<sal_Int8> getUnoTunnelId();
 
 
private:
    void checkLive();
 
    bool isLive() const;
 
    xforms::Model* getModelImpl() const;
 
    std::vector<xforms::EvaluationContext> _getMIPEvaluationContexts() const;
 
    void bind( bool bForceRebind = false );
 
    void valueModified();
 
    void bindingModified();
 
 
    MIP getLocalMIP() const;
 
    css::uno::Reference<css::xsd::XDataType> getDataType() const;
 
    bool isValid_DataType() const;
 
    OUString explainInvalid_DataType();
 
    void clear();
 
    void distributeMIP( const css::uno::Reference<css::xml::dom::XNode> &rxNode );
 
    css::uno::Reference<css::container::XNameContainer> _getNamespaces() const;
 
    void _setNamespaces( const css::uno::Reference<css::container::XNameContainer>&, bool bBinding );
 
    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: */