forms/source/xforms/binding.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "binding.hxx"
  22
  23 #include "model.hxx"
  24 #include "unohelper.hxx"
  25 #include "NameContainer.hxx"
  26 #include "evaluationcontext.hxx"
  27 #include "convert.hxx"
  28 #include "resourcehelper.hxx"
  29 #include "xmlhelper.hxx"
  30 #include "xformsevent.hxx"
  31 #include <strings.hrc>
  32
  33 #include <rtl/ustrbuf.hxx>
  34 #include <o3tl/safeint.hxx>
  35 #include <osl/diagnose.h>
  36
  37 #include <comphelper/diagnose_ex.hxx>
  38
  39 #include <algorithm>
  40 #include <functional>
  41
  42 #include <com/sun/star/form/binding/IncompatibleTypesException.hpp>
  43 #include <com/sun/star/form/binding/InvalidBindingStateException.hpp>
  44 #include <com/sun/star/uno/Any.hxx>
  45 #include <com/sun/star/xml/dom/XNodeList.hpp>
  46 #include <com/sun/star/xml/dom/XNode.hpp>
  47 #include <com/sun/star/xml/dom/XDocument.hpp>
  48 #include <com/sun/star/xml/dom/XElement.hpp>
  49 #include <com/sun/star/xml/dom/NodeType.hpp>
  50 #include <com/sun/star/xml/dom/events/XEventTarget.hpp>
  51 #include <com/sun/star/xml/dom/events/XEventListener.hpp>
  52 #include <com/sun/star/lang/XUnoTunnel.hpp>
  53 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  54 #include <com/sun/star/container/XNameContainer.hpp>
  55
  56 #include <comphelper/servicehelper.hxx>
  57
  58 using namespace com::sun::star::xml::xpath;
  59 using namespace com::sun::star::xml::dom::events;
  60
  61 using std::vector;
  62 using xforms::Binding;
  63 using xforms::MIP;
  64 using xforms::Model;
  65 using xforms::getResource;
  66 using xforms::EvaluationContext;
  67 using com::sun::star::beans::XPropertySet;
  68 using com::sun::star::container::XNameAccess;
  69 using com::sun::star::form::binding::IncompatibleTypesException;
  70 using com::sun::star::form::binding::InvalidBindingStateException;
  71 using com::sun::star::form::binding::XValueBinding;
  72 using com::sun::star::lang::EventObject;
  73 using com::sun::star::lang::IndexOutOfBoundsException;
  74 using com::sun::star::uno::Any;
  75 using com::sun::star::uno::Reference;
  76 using com::sun::star::uno::RuntimeException;
  77 using com::sun::star::uno::Sequence;
  78 using com::sun::star::uno::UNO_QUERY;
  79 using com::sun::star::uno::UNO_QUERY_THROW;
  80 using com::sun::star::uno::XInterface;
  81 using com::sun::star::uno::Exception;
  82 using com::sun::star::util::XModifyListener;
  83 using com::sun::star::xforms::XDataTypeRepository;
  84 using com::sun::star::xml::dom::NodeType_ATTRIBUTE_NODE;
  85 using com::sun::star::xml::dom::NodeType_TEXT_NODE;
  86 using com::sun::star::xml::dom::XNode;
  87 using com::sun::star::xml::dom::XNodeList;
  88 using com::sun::star::xml::dom::events::XEventListener;
  89 using com::sun::star::xml::dom::events::XEventTarget;
  90 using com::sun::star::xsd::XDataType;
  91
  92 #define HANDLE_BindingID 0
  93 #define HANDLE_BindingExpression 1
  94 #define HANDLE_Model 2
  95 #define HANDLE_ModelID 3
  96 #define HANDLE_BindingNamespaces 4
  97 #define HANDLE_ReadonlyExpression 5
  98 #define HANDLE_RelevantExpression 6
  99 #define HANDLE_RequiredExpression 7
 100 #define HANDLE_ConstraintExpression 8
 101 #define HANDLE_CalculateExpression 9
 102 #define HANDLE_Type 10
 103 #define HANDLE_ReadOnly 11  // from com.sun.star.form.binding.ValueBinding, for interaction with a bound form control
 104 #define HANDLE_Relevant 12  // from com.sun.star.form.binding.ValueBinding, for interaction with a bound form control
 105 #define HANDLE_ModelNamespaces 13
 106 #define HANDLE_ExternalData 14
 107
 108
 109 Binding::Binding() :
 110     mxNamespaces( new NameContainer<OUString>() ),
 111     mbInCalculate( false ),
 112     mnDeferModifyNotifications( 0 ),
 113     mbValueModified( false ),
 114     mbBindingModified( false )
 115 {
 116     initializePropertySet();
 117 }
 118
 119 Binding::~Binding()
 120 {
 121     _setModel(nullptr);
 122 }
 123
 124 void Binding::_setModel( const rtl::Reference<Model>& xModel )
 125 {
 126     PropertyChangeNotifier aNotifyModelChange( *this, HANDLE_Model );
 127     PropertyChangeNotifier aNotifyModelIDChange( *this, HANDLE_ModelID );
 128
 129     // prepare binding for removal of old model
 130     clear(); // remove all cached data (e.g. XPath evaluation results)
 131     css::uno::Reference<css::container::XNameContainer> xNamespaces = getModelNamespaces(); // save namespaces
 132
 133     mxModel = xModel;
 134
 135     // set namespaces (and move to model, if appropriate)
 136     setBindingNamespaces( xNamespaces );
 137     _checkBindingID();
 138
 139     notifyAndCachePropertyValue( HANDLE_ExternalData );
 140 }
 141
 142
 143 OUString Binding::getModelID() const
 144 {
 145     return ( mxModel == nullptr ) ? OUString() : mxModel->getID();
 146 }
 147
 148
 149 css::uno::Reference<css::xml::dom::XNodeList> Binding::getXNodeList()
 150 {
 151     // first make sure we are bound
 152     if( ! maBindingExpression.hasValue() )
 153         bind();
 154
 155     return maBindingExpression.getXNodeList();
 156 }
 157
 158 bool Binding::isSimpleBinding() const
 159 {
 160     return maBindingExpression.isSimpleExpression()
 161         && maReadonly.isSimpleExpression()
 162         && maRelevant.isSimpleExpression()
 163         && maRequired.isSimpleExpression()
 164         && maConstraint.isSimpleExpression()
 165         && maCalculate.isSimpleExpression();
 166 }
 167
 168 bool Binding::isSimpleBindingExpression() const
 169 {
 170     return maBindingExpression.isSimpleExpression();
 171 }
 172
 173 void Binding::update()
 174 {
 175     // clear all expressions (to remove cached node references)
 176     maBindingExpression.clear();
 177     maReadonly.clear();
 178     maRelevant.clear();
 179     maRequired.clear();
 180     maConstraint.clear();
 181     maCalculate.clear();
 182
 183     // let's just pretend the binding has been modified -> full rebind()
 184     bindingModified();
 185 }
 186
 187 void Binding::deferNotifications( bool bDefer )
 188 {
 189     mnDeferModifyNotifications += ( bDefer ? 1 : -1 );
 190     OSL_ENSURE( mnDeferModifyNotifications >= 0, "you're deferring too much" );
 191
 192     if( mnDeferModifyNotifications == 0 )
 193     {
 194         if( mbBindingModified )
 195             bindingModified();
 196         if( mbValueModified )
 197             valueModified();
 198     }
 199
 200     OSL_ENSURE( ( mnDeferModifyNotifications > 0 )
 201                 || ( ! mbBindingModified  &&  ! mbValueModified ),
 202                 "deferred modifications not delivered?" );
 203 }
 204
 205 bool Binding::isValid() const
 206 {
 207     // TODO: determine whether node is suitable, not just whether it exists
 208     return maBindingExpression.getNode().is() &&
 209         (
 210             // tdf#155121, validity rules should be apply when field is required or
 211             // when the field is not required but not empty
 212             // so if the field is not required and empty, do not check validity
 213             (! maMIP.isRequired() && maBindingExpression.hasValue()
 214                && maBindingExpression.getString().isEmpty() ) ||
 215             isValid_DataType()
 216         ) &&
 217         maMIP.isConstraint() &&
 218         ( ! maMIP.isRequired() ||
 219              ( maBindingExpression.hasValue() &&
 220                !maBindingExpression.getString().isEmpty() ) );
 221 }
 222
 223 bool Binding::isUseful() const
 224 {
 225     // we are useful, if
 226     // 0) we don't have a model
 227     //    (at least, in this case we shouldn't be removed from the model)
 228     // 1) we have a proper name
 229     // 2) we have some MIPs,
 230     // 3) we are bound to some control
 231     //    (this can be assumed if some listeners are set)
 232     bool bUseful =
 233         mxModel == nullptr
 234 //        || msBindingID.getLength() > 0
 235         || ! msTypeName.isEmpty()
 236         || ! maReadonly.isEmptyExpression()
 237         || ! maRelevant.isEmptyExpression()
 238         || ! maRequired.isEmptyExpression()
 239         || ! maConstraint.isEmptyExpression()
 240         || ! maCalculate.isEmptyExpression()
 241         || ! maModifyListeners.empty()
 242         || ! maListEntryListeners.empty()
 243         || ! maValidityListeners.empty();
 244
 245     return bUseful;
 246 }
 247
 248 OUString Binding::explainInvalid()
 249 {
 250     OUString sReason;
 251     if( ! maBindingExpression.getNode().is() )
 252     {
 253         sReason = ( maBindingExpression.getExpression().isEmpty() )
 254             ? getResource( RID_STR_XFORMS_NO_BINDING_EXPRESSION )
 255             : getResource( RID_STR_XFORMS_INVALID_BINDING_EXPRESSION );
 256     }
 257     else if( ! isValid_DataType() )
 258     {
 259         sReason = explainInvalid_DataType();
 260         if( sReason.isEmpty() )
 261         {
 262             // no explanation given by data type? Then give generic message
 263             sReason = getResource( RID_STR_XFORMS_INVALID_VALUE,
 264                                    maMIP.getTypeName() );
 265         }
 266     }
 267     else if( ! maMIP.isConstraint() )
 268     {
 269         sReason = maMIP.getConstraintExplanation();
 270     }
 271     else if( maMIP.isRequired() && maBindingExpression.hasValue() &&
 272         maBindingExpression.getString().isEmpty() )
 273     {
 274         sReason = getResource( RID_STR_XFORMS_REQUIRED );
 275     }
 276     // else: no explanation given; should only happen if data is valid
 277
 278     OSL_ENSURE( sReason.isEmpty() == isValid(),
 279                 "invalid data should have an explanation!" );
 280
 281     return sReason;
 282 }
 283
 284
 285 EvaluationContext Binding::getEvaluationContext() const
 286 {
 287     OSL_ENSURE( mxModel != nullptr, "need model impl" );
 288     EvaluationContext aContext = mxModel->getEvaluationContext();
 289     aContext.mxNamespaces = getBindingNamespaces();
 290     return aContext;
 291 }
 292
 293 ::std::vector<EvaluationContext> Binding::getMIPEvaluationContexts()
 294 {
 295     OSL_ENSURE( mxModel != nullptr, "need model impl" );
 296
 297     // bind (in case we were not bound before)
 298     bind();
 299     return _getMIPEvaluationContexts();
 300 }
 301
 302
 303 css::uno::Sequence<sal_Int8> Binding::getUnoTunnelId()
 304 {
 305     static const comphelper::UnoIdInit aImplementationId;
 306     return aImplementationId.getSeq();
 307 }
 308
 309
 310 void Binding::setBindingID( const OUString& sBindingID )
 311 {
 312     msBindingID = sBindingID;
 313 }
 314
 315 OUString Binding::getBindingExpression() const
 316 {
 317     return maBindingExpression.getExpression();
 318 }
 319
 320 void Binding::setBindingExpression( const OUString& sBindingExpression)
 321 {
 322     maBindingExpression.setExpression( sBindingExpression );
 323     bindingModified();
 324 }
 325
 326 OUString Binding::getReadonlyExpression() const
 327 {
 328     return maReadonly.getExpression();
 329 }
 330
 331 void Binding::setReadonlyExpression( const OUString& sReadonly)
 332 {
 333     maReadonly.setExpression( sReadonly );
 334     bindingModified();
 335 }
 336
 337 OUString Binding::getRelevantExpression() const
 338 {
 339     return maRelevant.getExpression();
 340 }
 341
 342 void Binding::setRelevantExpression( const OUString& sRelevant )
 343 {
 344     maRelevant.setExpression( sRelevant );
 345     bindingModified();
 346 }
 347
 348 OUString Binding::getRequiredExpression() const
 349 {
 350     return maRequired.getExpression();
 351 }
 352
 353 void Binding::setRequiredExpression( const OUString& sRequired )
 354 {
 355     maRequired.setExpression( sRequired );
 356     bindingModified();
 357 }
 358
 359 OUString Binding::getConstraintExpression() const
 360 {
 361     return maConstraint.getExpression();
 362 }
 363
 364 void Binding::setConstraintExpression( const OUString& sConstraint )
 365 {
 366     maConstraint.setExpression( sConstraint );
 367     msExplainConstraint = getResource( RID_STR_XFORMS_INVALID_CONSTRAINT,
 368                                        sConstraint );
 369
 370     // TODO: This should only re-evaluate the constraint, and notify
 371     // the validity constraint listeners; instead we currently pretend
 372     // the entire binding was notified, which does a little too much.
 373     bindingModified();
 374 }
 375
 376 OUString Binding::getCalculateExpression() const
 377 {
 378     return maCalculate.getExpression();
 379 }
 380
 381 void Binding::setCalculateExpression( const OUString& sCalculate )
 382 {
 383     maCalculate.setExpression( sCalculate );
 384     bindingModified();
 385 }
 386
 387
 388 void Binding::setType( const OUString& sTypeName )
 389 {
 390     msTypeName = sTypeName;
 391     bindingModified();
 392 }
 393
 394 void Binding::setBindingNamespaces( const css::uno::Reference<css::container::XNameContainer>& rNamespaces )
 395 {
 396     _setNamespaces( rNamespaces, true );
 397 }
 398
 399 css::uno::Reference<css::container::XNameContainer> Binding::getModelNamespaces() const
 400 {
 401     return _getNamespaces();
 402 }
 403
 404 void Binding::setModelNamespaces( const css::uno::Reference<css::container::XNameContainer>& rNamespaces )
 405 {
 406     _setNamespaces( rNamespaces, false );
 407 }
 408
 409 bool Binding::getReadOnly() const
 410 {
 411     return maMIP.isReadonly();
 412 }
 413
 414 bool Binding::getRelevant() const
 415 {
 416     return maMIP.isRelevant();
 417 }
 418
 419 bool Binding::getExternalData() const
 420 {
 421     bool bExternalData = true;
 422     if ( !mxModel.is() )
 423         return bExternalData;
 424
 425     try
 426     {
 427         OSL_VERIFY(
 428             mxModel->getPropertyValue( u"ExternalData"_ustr ) >>= bExternalData );
 429     }
 430     catch( const Exception& )
 431     {
 432         DBG_UNHANDLED_EXCEPTION("forms.xforms");
 433     }
 434     return bExternalData;
 435 }
 436
 437
 438 void Binding::checkLive()
 439 {
 440     if( ! isLive() )
 441         throw RuntimeException(u"Binding not initialized"_ustr, static_cast<XValueBinding*>(this));
 442 }
 443
 444 bool Binding::isLive() const
 445 {
 446     return mxModel && mxModel->isInitialized();
 447 }
 448
 449
 450 static void lcl_addListenerToNode( const Reference<XNode>& xNode,
 451                                    const Reference<XEventListener>& xListener )
 452 {
 453     Reference<XEventTarget> xTarget( xNode, UNO_QUERY );
 454     if( !xTarget.is() )
 455         return;
 456
 457     xTarget->addEventListener( u"DOMCharacterDataModified"_ustr,
 458                                xListener, false );
 459     xTarget->addEventListener( u"DOMCharacterDataModified"_ustr,
 460                                xListener, true );
 461     xTarget->addEventListener( u"DOMAttrModified"_ustr,
 462                                xListener, false );
 463     xTarget->addEventListener( u"DOMAttrModified"_ustr,
 464                                xListener, true );
 465     xTarget->addEventListener( u"xforms-generic"_ustr,
 466                                xListener, true );
 467 }
 468
 469 static void lcl_removeListenerFromNode( const Reference<XNode>& xNode,
 470                                         const Reference<XEventListener>& xListener )
 471 {
 472     Reference<XEventTarget> xTarget( xNode, UNO_QUERY );
 473     if( !xTarget.is() )
 474         return;
 475
 476     xTarget->removeEventListener( u"DOMCharacterDataModified"_ustr,
 477                                   xListener, false );
 478     xTarget->removeEventListener( u"DOMCharacterDataModified"_ustr,
 479                                   xListener, true );
 480     xTarget->removeEventListener( u"DOMAttrModified"_ustr,
 481                                   xListener, false );
 482     xTarget->removeEventListener( u"DOMAttrModified"_ustr,
 483                                   xListener, true );
 484     xTarget->removeEventListener( u"xforms-generic"_ustr,
 485                                   xListener, true );
 486 }
 487
 488 ::std::vector<EvaluationContext> Binding::_getMIPEvaluationContexts() const
 489 {
 490     OSL_ENSURE( mxModel != nullptr, "need model impl" );
 491
 492     // iterate over nodes of bind expression and create
 493     // EvaluationContext for each
 494     PathExpression::NodeVector_t aNodes = maBindingExpression.getNodeList();
 495     ::std::vector<EvaluationContext> aVector;
 496     for (auto const& node : aNodes)
 497     {
 498         OSL_ENSURE( node.is(), "no node?" );
 499
 500         // create proper evaluation context for this MIP
 501         aVector.emplace_back( node, mxModel, getBindingNamespaces() );
 502     }
 503     return aVector;
 504 }
 505
 506 void Binding::bind( bool bForceRebind )
 507 {
 508     if( ! mxModel.is() )
 509         throw RuntimeException(u"Binding has no Model"_ustr, static_cast<XValueBinding*>(this));
 510
 511     // bind() will evaluate this binding as follows:
 512     // 1) evaluate the binding expression
 513     // 1b) if necessary, create node according to 'lazy author' rules
 514     // 2) register suitable listeners on the instance (and remove old ones)
 515     // 3) remove old MIPs defined by this binding
 516     // 4) for every node in the binding nodeset do:
 517     //    1) create proper evaluation context for this MIP
 518     //    2) evaluate calculate expression (and push value into instance)
 519     //    3) evaluate remaining MIPs
 520     //    4) evaluate the locally defined MIPs, and push them to the model
 521
 522
 523     // 1) evaluate the binding expression
 524     EvaluationContext aContext = getEvaluationContext();
 525     maBindingExpression.evaluate( aContext );
 526     if( ! maBindingExpression.getNode().is() )
 527     {
 528         // 1b) create node (if valid element name)
 529         if( isValidQName( maBindingExpression.getExpression(),
 530                           aContext.mxNamespaces ) )
 531         {
 532             aContext.mxContextNode->appendChild(
 533                     aContext.mxContextNode->getOwnerDocument()->createElement(
 534                         maBindingExpression.getExpression() ) );
 535             maBindingExpression.evaluate( aContext );
 536             OSL_ENSURE( maBindingExpression.getNode().is(),
 537                         "we should bind to the newly inserted node!" );
 538         }
 539     }
 540     PathExpression::NodeVector_t aNodes = maBindingExpression.getNodeList();
 541
 542     // 2) register suitable listeners on the instance (and remove old ones)
 543     if( maEventNodes.empty() || bForceRebind )
 544     {
 545         for (auto const& eventNode : maEventNodes)
 546             lcl_removeListenerFromNode( eventNode, this );
 547         maEventNodes.clear();
 548         if( isSimpleBinding() )
 549             maEventNodes.insert(maEventNodes.end(), aNodes.begin(), aNodes.end());
 550         else
 551             maEventNodes.emplace_back( aContext.mxContextNode->getOwnerDocument(),
 552                                   UNO_QUERY_THROW );
 553         for (auto const& eventNode : maEventNodes)
 554             lcl_addListenerToNode( eventNode, this );
 555     }
 556
 557     // 3) remove old MIPs defined by this binding
 558     OSL_ENSURE( mxModel != nullptr, "need model" );
 559     mxModel->removeMIPs( this );
 560
 561     // 4) calculate all MIPs
 562     ::std::vector<EvaluationContext> aMIPContexts = _getMIPEvaluationContexts();
 563     for (auto & context : aMIPContexts)
 564     {
 565         EvaluationContext& rContext = context;
 566
 567         // evaluate calculate expression (and push value into instance)
 568         // (prevent recursion using mbInCalculate
 569         if( ! maCalculate.isEmptyExpression() )
 570         {
 571             if( ! mbInCalculate )
 572             {
 573                 mbInCalculate = true;
 574                 maCalculate.evaluate( rContext );
 575                 mxModel->setSimpleContent( rContext.mxContextNode,
 576                                           maCalculate.getString() );
 577                 mbInCalculate = false;
 578             }
 579         }
 580
 581         // now evaluate remaining MIPs in the appropriate context
 582         maReadonly.evaluate( rContext );
 583         maRelevant.evaluate( rContext );
 584         maRequired.evaluate( rContext );
 585         maConstraint.evaluate( rContext );
 586         // type is static; does not need updating
 587
 588         // evaluate the locally defined MIPs, and push them to the model
 589         mxModel->addMIP( this, rContext.mxContextNode, getLocalMIP() );
 590     }
 591 }
 592
 593
 594 // helper for Binding::valueModified
 595 static void lcl_modified( const css::uno::Reference<css::util::XModifyListener>& xListener,
 596                    const Reference<XInterface>& xSource )
 597 {
 598     OSL_ENSURE( xListener.is(), "no listener?" );
 599     xListener->modified( EventObject( xSource ) );
 600 }
 601
 602 // helper for Binding::valueModified
 603 static void lcl_listentry( const css::uno::Reference<css::form::binding::XListEntryListener>& xListener,
 604                     const Reference<XInterface>& xSource )
 605 {
 606     OSL_ENSURE( xListener.is(), "no listener?" );
 607     // TODO: send fine granular events
 608     xListener->allEntriesChanged( EventObject( xSource ) );
 609 }
 610
 611 // helper for Binding::valueModified
 612 static void lcl_validate( const css::uno::Reference<css::form::validation::XValidityConstraintListener>& xListener,
 613                    const Reference<XInterface>& xSource )
 614 {
 615     OSL_ENSURE( xListener.is(), "no listener?" );
 616     xListener->validityConstraintChanged( EventObject( xSource ) );
 617 }
 618
 619
 620 void Binding::valueModified()
 621 {
 622     // defer notifications, if so desired
 623     if( mnDeferModifyNotifications > 0 )
 624     {
 625         mbValueModified = true;
 626         return;
 627     }
 628     mbValueModified = false;
 629
 630     // query MIP used by our first node (also note validity)
 631     Reference<XNode> xNode = maBindingExpression.getNode();
 632     maMIP = mxModel->queryMIP( xNode );
 633
 634     // distribute MIPs _used_ by this binding
 635     if( xNode.is() )
 636     {
 637         notifyAndCachePropertyValue( HANDLE_ReadOnly );
 638         notifyAndCachePropertyValue( HANDLE_Relevant );
 639     }
 640
 641     // iterate over _value_ listeners and send each a modified signal,
 642     // using this object as source (will also update validity, because
 643     // control will query once the value has changed)
 644     Reference<XInterface> xSource = static_cast<XPropertySet*>( this );
 645     ::std::for_each( maModifyListeners.begin(),
 646               maModifyListeners.end(),
 647                      ::std::bind( lcl_modified, std::placeholders::_1, xSource ) );
 648     ::std::for_each( maListEntryListeners.begin(),
 649               maListEntryListeners.end(),
 650                      ::std::bind( lcl_listentry, std::placeholders::_1, xSource ) );
 651     ::std::for_each( maValidityListeners.begin(),
 652               maValidityListeners.end(),
 653                      ::std::bind( lcl_validate, std::placeholders::_1, xSource ) );
 654
 655     // now distribute MIPs to children
 656     if( xNode.is() )
 657         distributeMIP( xNode->getFirstChild() );
 658 }
 659
 660 void Binding::distributeMIP( const css::uno::Reference<css::xml::dom::XNode> & rxNode ) {
 661
 662     rtl::Reference<css::xforms::XFormsEventConcrete> pEvent = new css::xforms::XFormsEventConcrete;
 663     pEvent->initXFormsEvent(u"xforms-generic"_ustr, true, false);
 664
 665     // naive depth-first traversal
 666     css::uno::Reference<css::xml::dom::XNode> xNode( rxNode );
 667     while(xNode.is()) {
 668
 669         // notifications should be triggered at the
 670         // leaf nodes first, bubbling upwards the hierarchy.
 671         css::uno::Reference<css::xml::dom::XNode> child(xNode->getFirstChild());
 672         if(child.is())
 673             distributeMIP(child);
 674
 675         // we're standing at a particular node somewhere
 676         // below the one which changed a property (MIP).
 677         // bindings which are listening at this node will receive
 678         // a notification message about what exactly happened.
 679         Reference< XEventTarget > target(xNode,UNO_QUERY);
 680         target->dispatchEvent(pEvent);
 681
 682         xNode = xNode->getNextSibling();
 683     }
 684 }
 685
 686 void Binding::bindingModified()
 687 {
 688     // defer notifications, if so desired
 689     if( mnDeferModifyNotifications > 0 )
 690     {
 691         mbBindingModified = true;
 692         return;
 693     }
 694     mbBindingModified = false;
 695
 696     // rebind (if live); then call valueModified
 697     // A binding should be inert until its model is fully constructed.
 698     if( isLive() )
 699     {
 700         bind( true );
 701         valueModified();
 702     }
 703 }
 704
 705
 706 MIP Binding::getLocalMIP() const
 707 {
 708     MIP aMIP;
 709
 710     if( maReadonly.hasValue() )
 711         aMIP.setReadonly( maReadonly.getBool() );
 712     if( maRelevant.hasValue() )
 713         aMIP.setRelevant( maRelevant.getBool( true ) );
 714     if( maRequired.hasValue() )
 715         aMIP.setRequired( maRequired.getBool() );
 716     if( maConstraint.hasValue() )
 717     {
 718         aMIP.setConstraint( maConstraint.getBool( true ) );
 719         if( ! aMIP.isConstraint() )
 720             aMIP.setConstraintExplanation( msExplainConstraint );
 721     }
 722     if( !msTypeName.isEmpty() )
 723         aMIP.setTypeName( msTypeName );
 724
 725     // calculate: only handle presence of calculate; value set elsewhere
 726     aMIP.setHasCalculate( !maCalculate.isEmptyExpression() );
 727
 728     return aMIP;
 729 }
 730
 731 css::uno::Reference<css::xsd::XDataType> Binding::getDataType() const
 732 {
 733     OSL_ENSURE( mxModel.is(), "need model" );
 734     OSL_ENSURE( mxModel->getDataTypeRepository().is(), "need types" );
 735
 736     Reference<XDataTypeRepository> xRepository =
 737         mxModel->getDataTypeRepository();
 738     OUString sTypeName = maMIP.getTypeName();
 739
 740     return ( xRepository.is() && xRepository->hasByName( sTypeName ) )
 741         ? Reference<XDataType>( xRepository->getByName( sTypeName ), UNO_QUERY)
 742         : Reference<XDataType>( nullptr );
 743 }
 744
 745 bool Binding::isValid_DataType() const
 746 {
 747     Reference<XDataType> xDataType = getDataType();
 748     return !xDataType.is()
 749         || xDataType->validate( maBindingExpression.getString() );
 750 }
 751
 752 OUString Binding::explainInvalid_DataType()
 753 {
 754     Reference<XDataType> xDataType = getDataType();
 755     return xDataType.is()
 756         ? xDataType->explainInvalid( maBindingExpression.getString() )
 757         : OUString();
 758 }
 759
 760 void Binding::clear()
 761 {
 762     // remove MIPs contributed by this binding
 763     if( mxModel != nullptr )
 764         mxModel->removeMIPs( this );
 765
 766     // remove all references
 767     for (auto const& eventNode : maEventNodes)
 768         lcl_removeListenerFromNode( eventNode, this );
 769     maEventNodes.clear();
 770
 771     // clear expressions
 772     maBindingExpression.clear();
 773     maReadonly.clear();
 774     maRelevant.clear();
 775     maRequired.clear();
 776     maConstraint.clear();
 777     maCalculate.clear();
 778
 779     // TODO: what about our listeners?
 780 }
 781
 782
 783 static void lcl_removeOtherNamespaces( const css::uno::Reference<css::container::XNameContainer>& xFrom,
 784                                 css::uno::Reference<css::container::XNameContainer> const & xTo )
 785 {
 786     OSL_ENSURE( xFrom.is(), "no source" );
 787     OSL_ENSURE( xTo.is(), "no target" );
 788
 789     // iterate over name in source
 790     Sequence<OUString> aNames = xTo->getElementNames();
 791     sal_Int32 nNames = aNames.getLength();
 792     const OUString* pNames = aNames.getConstArray();
 793     for( sal_Int32 i = 0; i < nNames; i++ )
 794     {
 795         const OUString& rName = pNames[i];
 796
 797         if( ! xFrom->hasByName( rName ) )
 798             xTo->removeByName( rName );
 799     }
 800 }
 801
 802 /** copy namespaces from one namespace container into another
 803  * @param bOverwrite true: overwrite namespaces in target
 804  *                   false: do not overwrite namespaces in target
 805  * @param bMove true: move namespaces (i.e., delete in source)
 806  *              false: copy namespaces (do not modify source)
 807  * @param bFromSource true: use elements from source
 808  *                    false: use only elements from target
 809  */
 810 static void lcl_copyNamespaces( const css::uno::Reference<css::container::XNameContainer>& xFrom,
 811                          css::uno::Reference<css::container::XNameContainer> const & xTo,
 812                          bool bOverwrite )
 813 {
 814     OSL_ENSURE( xFrom.is(), "no source" );
 815     OSL_ENSURE( xTo.is(), "no target" );
 816
 817     // iterate over name in source
 818     Sequence<OUString> aNames = xFrom->getElementNames();
 819     sal_Int32 nNames = aNames.getLength();
 820     const OUString* pNames = aNames.getConstArray();
 821     for( sal_Int32 i = 0; i < nNames; i++ )
 822     {
 823         const OUString& rName = pNames[i];
 824
 825         // determine whether to copy the value, and whether to delete
 826         // it in the source:
 827
 828         bool bInTarget = xTo->hasByName( rName );
 829
 830         // we copy: if property is in target, and
 831         //          if bOverwrite is set, or when the namespace prefix is free
 832         bool bCopy = bOverwrite || ! bInTarget;
 833
 834         // and now... ACTION!
 835         if( bCopy )
 836         {
 837             if( bInTarget )
 838                 xTo->replaceByName( rName, xFrom->getByName( rName ) );
 839             else
 840                 xTo->insertByName( rName, xFrom->getByName( rName ) );
 841         }
 842     }
 843 }
 844
 845 // implement get*Namespaces()
 846 // (identical for both variants)
 847 css::uno::Reference<css::container::XNameContainer> Binding::_getNamespaces() const
 848 {
 849     css::uno::Reference<css::container::XNameContainer> xNamespaces = new NameContainer<OUString>();
 850     lcl_copyNamespaces( mxNamespaces, xNamespaces, true );
 851
 852     // merge model's with binding's own namespaces
 853     if( mxModel != nullptr )
 854         lcl_copyNamespaces( mxModel->getNamespaces(), xNamespaces, false );
 855
 856     return xNamespaces;
 857 }
 858
 859 // implement set*Namespaces()
 860 // bBinding = true: setBindingNamespaces, otherwise: setModelNamespaces
 861 void Binding::_setNamespaces( const css::uno::Reference<css::container::XNameContainer>& rNamespaces,
 862                               bool bBinding )
 863 {
 864     css::uno::Reference<css::container::XNameContainer> xModelNamespaces = ( mxModel != nullptr )
 865                                             ? mxModel->getNamespaces()
 866                                             : nullptr;
 867     OSL_ENSURE( ( mxModel != nullptr ) == xModelNamespaces.is(), "no model nmsp?");
 868
 869     // remove deleted namespaces
 870     lcl_removeOtherNamespaces( rNamespaces, mxNamespaces );
 871     if( !bBinding && xModelNamespaces.is() )
 872         lcl_removeOtherNamespaces( rNamespaces, xModelNamespaces );
 873
 874     // copy namespaces as appropriate
 875     Sequence<OUString> aNames = rNamespaces->getElementNames();
 876     sal_Int32 nNames = aNames.getLength();
 877     const OUString* pNames = aNames.getConstArray();
 878     for( sal_Int32 i = 0; i < nNames; i++ )
 879     {
 880         const OUString& rName = pNames[i];
 881         Any aValue = rNamespaces->getByName( rName );
 882
 883         // determine whether the namespace should go into model's or
 884         // into binding's namespaces
 885         bool bLocal =
 886             ! xModelNamespaces.is()
 887             || mxNamespaces->hasByName( rName )
 888             || ( bBinding
 889                  && xModelNamespaces.is()
 890                  && xModelNamespaces->hasByName( rName ) );
 891
 892         // write namespace into the appropriate namespace container
 893         css::uno::Reference<css::container::XNameContainer>& rWhich = bLocal ? mxNamespaces : xModelNamespaces;
 894         OSL_ENSURE( rWhich.is(), "whoops" );
 895         if( rWhich->hasByName( rName ) )
 896             rWhich->replaceByName( rName, aValue );
 897         else
 898             rWhich->insertByName( rName, aValue );
 899
 900         // always 'promote' namespaces from binding to model, if equal
 901         if( xModelNamespaces.is()
 902             && xModelNamespaces->hasByName( rName )
 903             && mxNamespaces->hasByName( rName )
 904             && xModelNamespaces->getByName( rName ) == mxNamespaces->getByName( rName ) )
 905         {
 906             mxNamespaces->removeByName( rName );
 907         }
 908     }
 909
 910     // ... done. But we modified the binding!
 911     bindingModified();
 912 }
 913
 914 void Binding::_checkBindingID()
 915 {
 916     if( !mxModel.is() )
 917         return;
 918
 919     Reference<XNameAccess> xBindings( mxModel->getBindings(), UNO_QUERY_THROW );
 920     if( !msBindingID.isEmpty() )
 921         return;
 922
 923     // no binding ID? then make one up!
 924     OUString sIDPrefix = getResource( RID_STR_XFORMS_BINDING_UI_NAME ) + " ";
 925     sal_Int32 nNumber = 0;
 926     OUString sName;
 927     do
 928     {
 929         nNumber++;
 930         sName = sIDPrefix + OUString::number( nNumber );
 931     }
 932     while( xBindings->hasByName( sName ) );
 933     setBindingID( sName );
 934 }
 935
 936
 937 // XValueBinding
 938
 939
 940 css::uno::Sequence<css::uno::Type> Binding::getSupportedValueTypes()
 941 {
 942     return Convert::get().getTypes();
 943 }
 944
 945 sal_Bool Binding::supportsType( const css::uno::Type& rType )
 946 {
 947     return Convert::get().hasType( rType );
 948 }
 949
 950 css::uno::Any Binding::getValue( const css::uno::Type& rType )
 951 {
 952     // first, check for model
 953     checkLive();
 954
 955     // second, check for type
 956     if( ! supportsType( rType ) )
 957         throw IncompatibleTypesException(u"type unsupported"_ustr, static_cast<XValueBinding*>(this));
 958
 959     // return string value (if present; else return empty Any)
 960     css::uno::Any result;
 961     if(maBindingExpression.hasValue()) {
 962         OUString pathExpr(maBindingExpression.getString());
 963         Convert &rConvert = Convert::get();
 964         result = rConvert.toAny(pathExpr,rType);
 965     }
 966
 967     return result;
 968 }
 969
 970 void Binding::setValue( const css::uno::Any& aValue )
 971 {
 972     // first, check for model
 973     checkLive();
 974
 975     // check for supported type
 976     if( ! supportsType( aValue.getValueType() ) )
 977         throw IncompatibleTypesException(u"type unsupported"_ustr, static_cast<XValueBinding*>(this));
 978
 979     if( !maBindingExpression.hasValue() )
 980         throw InvalidBindingStateException(u"no suitable node found"_ustr, static_cast<XValueBinding*>(this));
 981
 982     css::uno::Reference<css::xml::dom::XNode> xNode = maBindingExpression.getNode();
 983     if( !xNode.is() )
 984         throw InvalidBindingStateException(u"no suitable node found"_ustr, static_cast<XValueBinding*>(this));
 985
 986     OUString sValue = Convert::get().toXSD( aValue );
 987     bool bSuccess = mxModel->setSimpleContent( xNode, sValue );
 988     if( ! bSuccess )
 989         throw InvalidBindingStateException(u"can't set value"_ustr, static_cast<XValueBinding*>(this));
 990
 991
 992 }
 993
 994
 995 // XListEntry Source
 996
 997
 998 sal_Int32 Binding::getListEntryCount()
 999 {
1000     // first, check for model
1001     checkLive();
1002
1003     // return size of node list
1004     return maBindingExpression.getNodeList().size();
1005 }
1006
1007 static void lcl_getString( const Reference<XNode>& xNode, OUStringBuffer& rBuffer )
1008 {
1009     if( xNode->getNodeType() == NodeType_TEXT_NODE
1010         || xNode->getNodeType() == NodeType_ATTRIBUTE_NODE )
1011     {
1012         rBuffer.append( xNode->getNodeValue() );
1013     }
1014     else
1015     {
1016         for( Reference<XNode> xChild = xNode->getFirstChild();
1017              xChild.is();
1018              xChild = xChild->getNextSibling() )
1019         {
1020             lcl_getString( xChild, rBuffer );
1021         }
1022     }
1023 }
1024
1025 static OUString lcl_getString( const Reference<XNode>& xNode )
1026 {
1027     OUStringBuffer aBuffer;
1028     lcl_getString( xNode, aBuffer );
1029     return aBuffer.makeStringAndClear();
1030 }
1031
1032 OUString Binding::getListEntry( sal_Int32 nPosition )
1033 {
1034     // first, check for model
1035     checkLive();
1036
1037     // check bounds and return proper item
1038     PathExpression::NodeVector_t aNodes = maBindingExpression.getNodeList();
1039     if( nPosition < 0 || o3tl::make_unsigned(nPosition) >= aNodes.size() )
1040         throw IndexOutOfBoundsException(u""_ustr, static_cast<XValueBinding*>(this));
1041     return lcl_getString( aNodes[ nPosition ] );
1042 }
1043
1044 Sequence<OUString> Binding::getAllListEntries()
1045 {
1046     // first, check for model
1047     checkLive();
1048
1049     // create sequence of string values
1050     PathExpression::NodeVector_t aNodes = maBindingExpression.getNodeList();
1051     Sequence<OUString> aSequence( aNodes.size() );
1052     OUString* pSequence = aSequence.getArray();
1053     for( sal_Int32 n = 0; n < aSequence.getLength(); n++ )
1054     {
1055         pSequence[n] = lcl_getString( aNodes[n] );
1056     }
1057
1058     return aSequence;
1059 }
1060
1061 void Binding::addListEntryListener( const css::uno::Reference<css::form::binding::XListEntryListener>& xListener )
1062 {
1063     OSL_ENSURE( xListener.is(), "need listener!" );
1064     if( ::std::find( maListEntryListeners.begin(),
1065               maListEntryListeners.end(),
1066               xListener)
1067         == maListEntryListeners.end() )
1068         maListEntryListeners.push_back( xListener );
1069 }
1070
1071 void Binding::removeListEntryListener( const css::uno::Reference<css::form::binding::XListEntryListener>& xListener )
1072 {
1073     XListEntryListeners_t::iterator aIter =
1074         ::std::find( maListEntryListeners.begin(), maListEntryListeners.end(),
1075               xListener );
1076     if( aIter != maListEntryListeners.end() )
1077         maListEntryListeners.erase( aIter );
1078 }
1079
1080
1081 // XValidator
1082
1083
1084 sal_Bool Binding::isValid( const css::uno::Any& )
1085 {
1086     // first, check for model
1087     checkLive();
1088
1089     // ignore value; determine validate only on current data
1090     return isValid();
1091 }
1092
1093 OUString Binding::explainInvalid(
1094     const css::uno::Any& /*Value*/ )
1095 {
1096     // first, check for model
1097     checkLive();
1098
1099     // ignore value; determine explanation  only on current data
1100     return explainInvalid();
1101 }
1102
1103 void Binding::addValidityConstraintListener(
1104     const css::uno::Reference<css::form::validation::XValidityConstraintListener>& xListener )
1105 {
1106     OSL_ENSURE( xListener.is(), "need listener!" );
1107     if( ::std::find(maValidityListeners.begin(), maValidityListeners.end(), xListener)
1108         == maValidityListeners.end() )
1109         maValidityListeners.push_back( xListener );
1110 }
1111
1112 void Binding::removeValidityConstraintListener(
1113     const css::uno::Reference<css::form::validation::XValidityConstraintListener>& xListener )
1114 {
1115     XValidityConstraintListeners_t::iterator aIter =
1116         ::std::find( maValidityListeners.begin(), maValidityListeners.end(),
1117               xListener );
1118     if( aIter != maValidityListeners.end() )
1119         maValidityListeners.erase( aIter );
1120 }
1121
1122
1123 // xml::dom::event::XEventListener
1124
1125
1126 void Binding::handleEvent( const css::uno::Reference<css::xml::dom::events::XEvent>& xEvent )
1127 {
1128     OUString sType(xEvent->getType());
1129     //OUString sEventMIPChanged("xforms-generic");
1130     //if(sType.equals(sEventMIPChanged)) {
1131     if(sType == "xforms-generic") {
1132
1133         // the modification of the 'mnDeferModifyNotifications'-member
1134         // is necessary to prevent infinite notification looping.
1135         // This can happened in case the binding which caused
1136         // the notification chain is listening to those events
1137         // as well...
1138         bool bPreserveValueModified = mbValueModified;
1139         mnDeferModifyNotifications++;
1140         valueModified();
1141         --mnDeferModifyNotifications;
1142         mbValueModified = bPreserveValueModified;
1143         return;
1144     }
1145
1146     // if we're a dynamic binding, we better re-bind, too!
1147     bind();
1148
1149     // our value was maybe modified
1150     valueModified();
1151 }
1152
1153
1154 // lang::XUnoTunnel
1155
1156
1157 sal_Int64 Binding::getSomething( const css::uno::Sequence<sal_Int8>& xId )
1158 {
1159     return comphelper::getSomethingImpl(xId, this);
1160 }
1161
1162
1163 // XCloneable
1164
1165
1166 css::uno::Reference<css::util::XCloneable> SAL_CALL Binding::createClone()
1167 {
1168     Reference< XPropertySet > xClone;
1169
1170     if ( mxModel )
1171         xClone = mxModel->cloneBinding( this );
1172     else
1173     {
1174         xClone = new Binding;
1175         copy( this, xClone );
1176     }
1177     return css::uno::Reference<css::util::XCloneable>( xClone, UNO_QUERY );
1178 }
1179
1180 css::uno::Reference<css::xforms::XModel> Binding::getModel() const
1181 {
1182     return mxModel;
1183 }
1184
1185 // property set implementations
1186
1187 void Binding::initializePropertySet()
1188 {
1189     registerProperty( css::beans::Property(u"BindingID"_ustr, HANDLE_BindingID, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1190     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setBindingID, &Binding::getBindingID));
1191
1192     registerProperty( css::beans::Property(u"BindingExpression"_ustr, HANDLE_BindingExpression, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1193     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setBindingExpression, &Binding::getBindingExpression));
1194
1195     registerProperty( css::beans::Property(u"Model"_ustr, HANDLE_Model, cppu::UnoType<css::uno::Reference<css::xforms::XModel>>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::READONLY ),
1196     new DirectPropertyAccessor< Binding, css::uno::Reference<css::xforms::XModel> >(this, nullptr, &Binding::getModel));
1197
1198     registerProperty( css::beans::Property(u"BindingNamespaces"_ustr, HANDLE_BindingNamespaces, cppu::UnoType<css::uno::Reference<css::container::XNameContainer>>::get(), css::beans::PropertyAttribute::BOUND ),
1199     new DirectPropertyAccessor< Binding, css::uno::Reference<css::container::XNameContainer> >(this, &Binding::setBindingNamespaces, &Binding::getBindingNamespaces));
1200
1201     registerProperty( css::beans::Property(u"ModelNamespaces"_ustr, HANDLE_ModelNamespaces, cppu::UnoType<css::uno::Reference<css::container::XNameContainer>>::get(), css::beans::PropertyAttribute::BOUND ),
1202     new DirectPropertyAccessor< Binding, css::uno::Reference<css::container::XNameContainer> >(this, &Binding::setModelNamespaces, &Binding::getModelNamespaces));
1203
1204     registerProperty( css::beans::Property(u"ModelID"_ustr, HANDLE_ModelID, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::READONLY ),
1205     new DirectPropertyAccessor< Binding, OUString >(this, nullptr, &Binding::getModelID));
1206
1207     registerProperty( css::beans::Property(u"ReadonlyExpression"_ustr, HANDLE_ReadonlyExpression, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1208     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setReadonlyExpression, &Binding::getReadonlyExpression));
1209
1210     registerProperty( css::beans::Property(u"RelevantExpression"_ustr, HANDLE_RelevantExpression, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1211     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setRelevantExpression, &Binding::getRelevantExpression));
1212
1213     registerProperty( css::beans::Property(u"RequiredExpression"_ustr, HANDLE_RequiredExpression, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1214     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setRequiredExpression, &Binding::getRequiredExpression));
1215
1216     registerProperty( css::beans::Property(u"ConstraintExpression"_ustr, HANDLE_ConstraintExpression, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1217     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setConstraintExpression, &Binding::getConstraintExpression));
1218
1219     registerProperty( css::beans::Property(u"CalculateExpression"_ustr, HANDLE_CalculateExpression, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1220     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setCalculateExpression, &Binding::getCalculateExpression));
1221
1222     registerProperty( css::beans::Property(u"Type"_ustr, HANDLE_Type, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND ),
1223     new DirectPropertyAccessor< Binding, OUString >(this, &Binding::setType, &Binding::getType));
1224
1225     registerProperty( css::beans::Property(u"ReadOnly"_ustr, HANDLE_ReadOnly, cppu::UnoType<bool>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::READONLY ),
1226     new DirectPropertyAccessor< Binding, bool >(this, nullptr, &Binding::getReadOnly));
1227
1228     registerProperty( css::beans::Property(u"Relevant"_ustr, HANDLE_Relevant, cppu::UnoType<bool>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::READONLY ),
1229     new DirectPropertyAccessor< Binding, bool >(this, nullptr, &Binding::getRelevant));
1230
1231     registerProperty( css::beans::Property(u"ExternalData"_ustr, HANDLE_ExternalData, cppu::UnoType<sal_Bool>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::READONLY ),
1232     new BooleanPropertyAccessor< Binding >(this, nullptr, &Binding::getExternalData));
1233
1234     initializePropertyValueCache( HANDLE_ReadOnly );
1235     initializePropertyValueCache( HANDLE_Relevant );
1236     initializePropertyValueCache( HANDLE_ExternalData );
1237 }
1238
1239 void Binding::addModifyListener(
1240     const css::uno::Reference<css::util::XModifyListener>& xListener )
1241 {
1242     OSL_ENSURE( xListener.is(), "need listener!" );
1243     if( ::std::find( maModifyListeners.begin(), maModifyListeners.end(), xListener )
1244           == maModifyListeners.end() )
1245         maModifyListeners.push_back( xListener );
1246
1247     // HACK: currently, we have to 'push' some MIPs to the control
1248     // (read-only, relevant, etc.) To enable this, we need to update
1249     // the control at least once when it registers here.
1250     valueModified();
1251 }
1252
1253 void Binding::removeModifyListener(
1254     const css::uno::Reference<css::util::XModifyListener>& xListener )
1255 {
1256     ModifyListeners_t::iterator aIter =
1257         ::std::find( maModifyListeners.begin(), maModifyListeners.end(), xListener );
1258     if( aIter != maModifyListeners.end() )
1259         maModifyListeners.erase( aIter );
1260 }
1261
1262
1263 OUString Binding::getName()
1264 {
1265     return getBindingID();
1266 }
1267
1268 void SAL_CALL Binding::setName( const OUString& rName )
1269 {
1270     // use the XPropertySet methods, so the change in the name is notified to the
1271     // property listeners
1272     setFastPropertyValue( HANDLE_BindingID, Any( rName ) );
1273 }
1274
1275 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */