extensions/source/propctrlr/eformshelper.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 #include <string_view>
  21
  22 #include "eformshelper.hxx"
  23 #include "formstrings.hxx"
  24 #include <strings.hrc>
  25 #include "modulepcr.hxx"
  26 #include "propeventtranslation.hxx"
  27 #include "formbrowsertools.hxx"
  28
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/form/FormComponentType.hpp>
  31 #include <com/sun/star/xforms/XFormsUIHelper1.hpp>
  32 #include <com/sun/star/xsd/DataTypeClass.hpp>
  33 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  34 #include <comphelper/diagnose_ex.hxx>
  35
  36 #include <algorithm>
  37 #include <o3tl/functional.hxx>
  38
  39 namespace pcr
  40 {
  41
  42
  43     using namespace ::com::sun::star;
  44     using namespace ::com::sun::star::uno;
  45     using namespace ::com::sun::star::beans;
  46     using namespace ::com::sun::star::container;
  47     using namespace ::com::sun::star::form::binding;
  48     using namespace ::com::sun::star::xsd;
  49     using namespace ::com::sun::star::lang;
  50     using namespace ::com::sun::star::form;
  51
  52
  53     //= file-local helpers
  54
  55     namespace
  56     {
  57
  58         OUString composeModelElementUIName( std::u16string_view _rModelName, std::u16string_view _rElementName )
  59         {
  60             OUString a = OUString::Concat("[")
  61                        + _rModelName + "] "
  62                        + _rElementName;
  63             return a;
  64         }
  65     }
  66
  67
  68     //= EFormsHelper
  69
  70
  71     EFormsHelper::EFormsHelper( ::osl::Mutex& _rMutex, const Reference< XPropertySet >& _rxControlModel, const Reference< frame::XModel >& _rxContextDocument )
  72         :m_xControlModel( _rxControlModel )
  73         ,m_aPropertyListeners( _rMutex )
  74     {
  75         OSL_ENSURE( _rxControlModel.is(), "EFormsHelper::EFormsHelper: invalid control model!" );
  76         m_xBindableControl.set(_rxControlModel, css::uno::UNO_QUERY);
  77
  78         m_xDocument.set(_rxContextDocument, css::uno::UNO_QUERY);
  79         OSL_ENSURE( m_xDocument.is(), "EFormsHelper::EFormsHelper: invalid document!" );
  80
  81     }
  82
  83
  84     bool EFormsHelper::isEForm( const Reference< frame::XModel >& _rxContextDocument )
  85     {
  86         try
  87         {
  88             Reference< xforms::XFormsSupplier > xDocument( _rxContextDocument, UNO_QUERY );
  89             if ( !xDocument.is() )
  90                 return false;
  91
  92             return xDocument->getXForms().is();
  93         }
  94         catch( const Exception& )
  95         {
  96             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::isEForm" );
  97         }
  98         return false;
  99     }
 100
 101
 102     bool EFormsHelper::canBindToDataType( sal_Int32 _nDataType ) const
 103     {
 104         if ( !m_xBindableControl.is() )
 105             // cannot bind at all
 106             return false;
 107
 108         // some types cannot be bound, independent from the control type
 109         if (  ( DataTypeClass::hexBinary == _nDataType )
 110            || ( DataTypeClass::base64Binary == _nDataType )
 111            || ( DataTypeClass::QName == _nDataType )
 112            || ( DataTypeClass::NOTATION == _nDataType )
 113            )
 114            return false;
 115
 116         bool bCan = false;
 117         try
 118         {
 119             // classify the control model
 120             sal_Int16 nControlType = FormComponentType::CONTROL;
 121             OSL_VERIFY( m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nControlType );
 122
 123             // some lists
 124             sal_Int16 const nNumericCompatibleTypes[] = { DataTypeClass::DECIMAL, DataTypeClass::FLOAT, DataTypeClass::DOUBLE, 0 };
 125             sal_Int16 const nDateCompatibleTypes[] = { DataTypeClass::DATE, 0 };
 126             sal_Int16 const nTimeCompatibleTypes[] = { DataTypeClass::TIME, 0 };
 127             sal_Int16 const nCheckboxCompatibleTypes[] = { DataTypeClass::BOOLEAN, DataTypeClass::STRING, DataTypeClass::anyURI, 0 };
 128             sal_Int16 const nRadiobuttonCompatibleTypes[] = { DataTypeClass::STRING, DataTypeClass::anyURI, 0 };
 129             sal_Int16 const nFormattedCompatibleTypes[] = { DataTypeClass::DECIMAL, DataTypeClass::FLOAT, DataTypeClass::DOUBLE, DataTypeClass::DATETIME, DataTypeClass::DATE, DataTypeClass::TIME, 0 };
 130
 131             sal_Int16 const * pCompatibleTypes = nullptr;
 132             switch ( nControlType )
 133             {
 134             case FormComponentType::SPINBUTTON:
 135             case FormComponentType::NUMERICFIELD:
 136                 pCompatibleTypes = nNumericCompatibleTypes;
 137                 break;
 138             case FormComponentType::DATEFIELD:
 139                 pCompatibleTypes = nDateCompatibleTypes;
 140                 break;
 141             case FormComponentType::TIMEFIELD:
 142                 pCompatibleTypes = nTimeCompatibleTypes;
 143                 break;
 144             case FormComponentType::CHECKBOX:
 145                 pCompatibleTypes = nCheckboxCompatibleTypes;
 146                 break;
 147             case FormComponentType::RADIOBUTTON:
 148                 pCompatibleTypes = nRadiobuttonCompatibleTypes;
 149                 break;
 150
 151             case FormComponentType::TEXTFIELD:
 152             {
 153                 // both the normal text field, and the formatted field, claim to be a TEXTFIELD
 154                 // need to distinguish by service name
 155                 Reference< XServiceInfo > xSI( m_xControlModel, UNO_QUERY );
 156                 OSL_ENSURE( xSI.is(), "EFormsHelper::canBindToDataType: a control model which has no service info?" );
 157                 if ( xSI.is() )
 158                 {
 159                     if ( xSI->supportsService( SERVICE_COMPONENT_FORMATTEDFIELD ) )
 160                     {
 161                         pCompatibleTypes = nFormattedCompatibleTypes;
 162                         break;
 163                     }
 164                 }
 165                 [[fallthrough]];
 166             }
 167             case FormComponentType::LISTBOX:
 168             case FormComponentType::COMBOBOX:
 169                 // edit fields and list/combo boxes can be bound to anything
 170                 bCan = true;
 171             }
 172
 173             if ( !bCan && pCompatibleTypes )
 174             {
 175                 if ( _nDataType == -1 )
 176                 {
 177                     // the control can be bound to at least one type, and exactly this is being asked for
 178                     bCan = true;
 179                 }
 180                 else
 181                 {
 182                     while ( *pCompatibleTypes && !bCan )
 183                         bCan = ( *pCompatibleTypes++ == _nDataType );
 184                 }
 185             }
 186         }
 187         catch( const Exception& )
 188         {
 189             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::canBindToDataType" );
 190         }
 191
 192         return bCan;
 193     }
 194
 195
 196     bool EFormsHelper::isListEntrySink() const
 197     {
 198         bool bIs = false;
 199         try
 200         {
 201             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
 202             bIs = xAsSink.is();
 203         }
 204         catch( const Exception& )
 205         {
 206             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::isListEntrySink" );
 207         }
 208         return bIs;
 209     }
 210
 211
 212     void EFormsHelper::impl_switchBindingListening_throw( bool _bDoListening, const Reference< XPropertyChangeListener >& _rxListener )
 213     {
 214         Reference< XPropertySet > xBindingProps;
 215         if ( m_xBindableControl.is() )
 216             xBindingProps.set(m_xBindableControl->getValueBinding(), css::uno::UNO_QUERY);
 217         if ( !xBindingProps.is() )
 218             return;
 219
 220         if ( _bDoListening )
 221         {
 222             xBindingProps->addPropertyChangeListener( OUString(), _rxListener );
 223         }
 224         else
 225         {
 226             xBindingProps->removePropertyChangeListener( OUString(), _rxListener );
 227         }
 228     }
 229
 230
 231     void EFormsHelper::registerBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener )
 232     {
 233         if ( !_rxBindingListener.is() )
 234             return;
 235         impl_toggleBindingPropertyListening_throw( true, _rxBindingListener );
 236     }
 237
 238
 239     void EFormsHelper::impl_toggleBindingPropertyListening_throw( bool _bDoListen, const Reference< XPropertyChangeListener >& _rxConcreteListenerOrNull )
 240     {
 241         if ( !_bDoListen )
 242         {
 243             ::comphelper::OInterfaceIteratorHelper3 aListenerIterator(m_aPropertyListeners);
 244             while ( aListenerIterator.hasMoreElements() )
 245             {
 246                 PropertyEventTranslation* pTranslator = dynamic_cast< PropertyEventTranslation* >( aListenerIterator.next().get() );
 247                 OSL_ENSURE( pTranslator, "EFormsHelper::impl_toggleBindingPropertyListening_throw: invalid listener element in my container!" );
 248                 if ( !pTranslator )
 249                     continue;
 250
 251                 Reference< XPropertyChangeListener > xEventSourceTranslator( pTranslator );
 252                 if ( _rxConcreteListenerOrNull.is() )
 253                 {
 254                     if ( pTranslator->getDelegator() == _rxConcreteListenerOrNull )
 255                     {
 256                         impl_switchBindingListening_throw( false, xEventSourceTranslator );
 257                         m_aPropertyListeners.removeInterface( xEventSourceTranslator );
 258                         break;
 259                     }
 260                 }
 261                 else
 262                 {
 263                     impl_switchBindingListening_throw( false, xEventSourceTranslator );
 264                 }
 265             }
 266         }
 267         else
 268         {
 269             if ( _rxConcreteListenerOrNull.is() )
 270             {
 271                 Reference< XPropertyChangeListener > xEventSourceTranslator( new PropertyEventTranslation( _rxConcreteListenerOrNull, m_xBindableControl ) );
 272                 m_aPropertyListeners.addInterface( xEventSourceTranslator );
 273                 impl_switchBindingListening_throw( true, xEventSourceTranslator );
 274             }
 275             else
 276             {
 277                 ::comphelper::OInterfaceIteratorHelper3 aListenerIterator(m_aPropertyListeners);
 278                 while ( aListenerIterator.hasMoreElements() )
 279                     impl_switchBindingListening_throw( true, aListenerIterator.next() );
 280             }
 281         }
 282     }
 283
 284
 285     void EFormsHelper::revokeBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener )
 286     {
 287         impl_toggleBindingPropertyListening_throw( false, _rxBindingListener );
 288     }
 289
 290
 291     void EFormsHelper::getFormModelNames( std::vector< OUString >& /* [out] */ _rModelNames ) const
 292     {
 293         if ( !m_xDocument.is() )
 294             return;
 295
 296         try
 297         {
 298             _rModelNames.resize( 0 );
 299
 300             Reference< XNameContainer > xForms( m_xDocument->getXForms() );
 301             OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelNames: invalid forms container!" );
 302             if ( xForms.is() )
 303             {
 304                 const Sequence< OUString > aModelNames = xForms->getElementNames();
 305                 _rModelNames.resize( aModelNames.getLength() );
 306                 std::copy( aModelNames.begin(), aModelNames.end(), _rModelNames.begin() );
 307             }
 308         }
 309         catch( const Exception& )
 310         {
 311             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getFormModelNames" );
 312         }
 313     }
 314
 315
 316     void EFormsHelper::getBindingNames( const OUString& _rModelName, std::vector< OUString >& /* [out] */ _rBindingNames ) const
 317     {
 318         _rBindingNames.resize( 0 );
 319         try
 320         {
 321             Reference< xforms::XModel > xModel( getFormModelByName( _rModelName ) );
 322             if ( xModel.is() )
 323             {
 324                 Reference< XNameAccess > xBindings( xModel->getBindings(), UNO_QUERY );
 325                 OSL_ENSURE( xBindings.is(), "EFormsHelper::getBindingNames: invalid bindings container obtained from the model!" );
 326                 if ( xBindings.is() )
 327                 {
 328                     const Sequence< OUString > aNames = xBindings->getElementNames();
 329                     _rBindingNames.resize( aNames.getLength() );
 330                     std::copy( aNames.begin(), aNames.end(), _rBindingNames.begin() );
 331                 }
 332             }
 333         }
 334         catch( const Exception& )
 335         {
 336             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getBindingNames" );
 337         }
 338     }
 339
 340
 341     Reference< xforms::XModel > EFormsHelper::getFormModelByName( const OUString& _rModelName ) const
 342     {
 343         Reference< xforms::XModel > xReturn;
 344         try
 345         {
 346             Reference< XNameContainer > xForms( m_xDocument->getXForms() );
 347             OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelByName: invalid forms container!" );
 348             if ( xForms.is() )
 349                 OSL_VERIFY( xForms->getByName( _rModelName ) >>= xReturn );
 350         }
 351         catch( const Exception& )
 352         {
 353             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getFormModelByName" );
 354         }
 355         return xReturn;
 356     }
 357
 358
 359     Reference< xforms::XModel > EFormsHelper::getCurrentFormModel() const
 360     {
 361         Reference< xforms::XModel > xModel;
 362         try
 363         {
 364             Reference< XPropertySet > xBinding( getCurrentBinding() );
 365             if ( xBinding.is() )
 366             {
 367                 OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_MODEL ) >>= xModel );
 368             }
 369         }
 370         catch( const Exception& )
 371         {
 372             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getCurrentFormModel" );
 373         }
 374         return xModel;
 375     }
 376
 377     OUString EFormsHelper::getCurrentFormModelName() const
 378     {
 379         OUString sModelName;
 380         try
 381         {
 382             Reference< xforms::XModel > xFormsModel( getCurrentFormModel() );
 383             if ( xFormsModel.is() )
 384                 sModelName = xFormsModel->getID();
 385         }
 386         catch( const Exception& )
 387         {
 388             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getCurrentFormModel" );
 389         }
 390         return sModelName;
 391     }
 392
 393     Reference< XPropertySet > EFormsHelper::getCurrentBinding() const
 394     {
 395         Reference< XPropertySet > xBinding;
 396
 397         try
 398         {
 399             if ( m_xBindableControl.is() )
 400                 xBinding.set(m_xBindableControl->getValueBinding(), css::uno::UNO_QUERY);
 401         }
 402         catch( const Exception& )
 403         {
 404             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getCurrentBinding" );
 405         }
 406
 407         return xBinding;
 408     }
 409
 410     OUString EFormsHelper::getCurrentBindingName() const
 411     {
 412         OUString sBindingName;
 413         try
 414         {
 415             Reference< XPropertySet > xBinding( getCurrentBinding() );
 416             if ( xBinding.is() )
 417                 xBinding->getPropertyValue( PROPERTY_BINDING_ID ) >>= sBindingName;
 418         }
 419         catch( const Exception& )
 420         {
 421             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getCurrentBindingName" );
 422         }
 423         return sBindingName;
 424     }
 425
 426
 427     Reference< XListEntrySource > EFormsHelper::getCurrentListSourceBinding() const
 428     {
 429         try
 430         {
 431             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
 432             OSL_ENSURE( xAsSink.is(), "EFormsHelper::getCurrentListSourceBinding: you should have used isListEntrySink before!" );
 433             if (xAsSink.is())
 434                 return xAsSink->getListEntrySource();
 435         }
 436         catch( const Exception& )
 437         {
 438             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getCurrentListSourceBinding" );
 439         }
 440         return Reference<XListEntrySource>();
 441     }
 442
 443
 444     void EFormsHelper::setListSourceBinding( const Reference< XListEntrySource >& _rxListSource )
 445     {
 446         try
 447         {
 448             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
 449             OSL_ENSURE( xAsSink.is(), "EFormsHelper::setListSourceBinding: you should have used isListEntrySink before!" );
 450             if ( xAsSink.is() )
 451                 xAsSink->setListEntrySource( _rxListSource );
 452         }
 453         catch( const Exception& )
 454         {
 455             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::setListSourceBinding" );
 456         }
 457     }
 458
 459     void EFormsHelper::setBinding( const Reference< css::beans::XPropertySet >& _rxBinding )
 460     {
 461         if ( !m_xBindableControl.is() )
 462             return;
 463
 464         try
 465         {
 466             Reference< XPropertySet > xOldBinding( m_xBindableControl->getValueBinding(), UNO_QUERY );
 467
 468             Reference< XValueBinding > xBinding( _rxBinding, UNO_QUERY );
 469             OSL_ENSURE( xBinding.is() || !_rxBinding.is(), "EFormsHelper::setBinding: invalid binding!" );
 470
 471             impl_toggleBindingPropertyListening_throw( false, nullptr );
 472             m_xBindableControl->setValueBinding( xBinding );
 473             impl_toggleBindingPropertyListening_throw( true, nullptr );
 474
 475             std::set< OUString > aSet;
 476             firePropertyChanges( xOldBinding, _rxBinding, aSet );
 477         }
 478         catch( const Exception& )
 479         {
 480             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::setBinding" );
 481         }
 482     }
 483
 484
 485     Reference< XPropertySet > EFormsHelper::getOrCreateBindingForModel( const OUString& _rTargetModel, const OUString& _rBindingName ) const
 486     {
 487         OSL_ENSURE( !_rBindingName.isEmpty(), "EFormsHelper::getOrCreateBindingForModel: invalid binding name!" );
 488         return implGetOrCreateBinding( _rTargetModel, _rBindingName );
 489     }
 490
 491
 492     Reference< XPropertySet > EFormsHelper::implGetOrCreateBinding( const OUString& _rTargetModel, const OUString& _rBindingName ) const
 493     {
 494         OSL_ENSURE( !( _rTargetModel.isEmpty() && !_rBindingName.isEmpty() ), "EFormsHelper::implGetOrCreateBinding: no model, but a binding name?" );
 495
 496         Reference< XPropertySet > xBinding;
 497         try
 498         {
 499             OUString sTargetModel( _rTargetModel );
 500             // determine the model which the binding should belong to
 501             if ( sTargetModel.isEmpty() )
 502             {
 503                 std::vector< OUString > aModelNames;
 504                 getFormModelNames( aModelNames );
 505                 if ( !aModelNames.empty() )
 506                     sTargetModel = *aModelNames.begin();
 507                 OSL_ENSURE( !sTargetModel.isEmpty(), "EFormsHelper::implGetOrCreateBinding: unable to obtain a default model!" );
 508             }
 509             Reference< xforms::XModel > xModel( getFormModelByName( sTargetModel ) );
 510             Reference< XNameAccess > xBindingNames( xModel.is() ? xModel->getBindings() : Reference< XSet >(), UNO_QUERY );
 511             if ( xBindingNames.is() )
 512             {
 513                 // get or create the binding instance
 514                 if ( !_rBindingName.isEmpty() )
 515                 {
 516                     if ( xBindingNames->hasByName( _rBindingName ) )
 517                         OSL_VERIFY( xBindingNames->getByName( _rBindingName ) >>= xBinding );
 518                     else
 519                     {
 520                         xBinding = xModel->createBinding( );
 521                         if ( xBinding.is() )
 522                         {
 523                             xBinding->setPropertyValue( PROPERTY_BINDING_ID, Any( _rBindingName ) );
 524                             xModel->getBindings()->insert( Any( xBinding ) );
 525                         }
 526                     }
 527                 }
 528                 else
 529                 {
 530                     xBinding = xModel->createBinding( );
 531                     if ( xBinding.is() )
 532                     {
 533                         // find a nice name for it
 534                         OUString sBaseName(PcrRes(RID_STR_BINDING_NAME) + " ");
 535                         OUString sNewName;
 536                         sal_Int32 nNumber = 1;
 537                         do
 538                         {
 539                             sNewName = sBaseName + OUString::number( nNumber++ );
 540                         }
 541                         while ( xBindingNames->hasByName( sNewName ) );
 542                         Reference< XNamed > xName( xBinding, UNO_QUERY_THROW );
 543                         xName->setName( sNewName );
 544                         // and insert into the model
 545                         xModel->getBindings()->insert( Any( xBinding ) );
 546                     }
 547                 }
 548             }
 549         }
 550         catch( const Exception& )
 551         {
 552             DBG_UNHANDLED_EXCEPTION("extensions.propctrlr");
 553         }
 554
 555         return xBinding;
 556     }
 557
 558
 559     namespace
 560     {
 561
 562         struct PropertyBagInserter
 563         {
 564         private:
 565             PropertyBag& m_rProperties;
 566
 567         public:
 568             explicit PropertyBagInserter( PropertyBag& rProperties ) : m_rProperties( rProperties ) { }
 569
 570             void operator()( const Property& _rProp )
 571             {
 572                 m_rProperties.insert( _rProp );
 573             }
 574         };
 575
 576
 577         Reference< XPropertySetInfo > collectPropertiesGetInfo( const Reference< XPropertySet >& _rxProps, PropertyBag& _rBag )
 578         {
 579             Reference< XPropertySetInfo > xInfo;
 580             if ( _rxProps.is() )
 581                 xInfo = _rxProps->getPropertySetInfo();
 582             if ( xInfo.is() )
 583             {
 584                 const Sequence< Property > aProperties = xInfo->getProperties();
 585                 std::for_each( aProperties.begin(), aProperties.end(),
 586                     PropertyBagInserter( _rBag )
 587                 );
 588             }
 589             return xInfo;
 590         }
 591     }
 592
 593
 594     OUString EFormsHelper::getModelElementUIName( const EFormsHelper::ModelElementType _eType, const Reference< XPropertySet >& _rxElement )
 595     {
 596         OUString sUIName;
 597         try
 598         {
 599             // determine the model which the element belongs to
 600             Reference< xforms::XFormsUIHelper1 > xHelper;
 601             if ( _rxElement.is() )
 602                 _rxElement->getPropertyValue( PROPERTY_MODEL ) >>= xHelper;
 603             OSL_ENSURE( xHelper.is(), "EFormsHelper::getModelElementUIName: invalid element or model!" );
 604             if ( xHelper.is() )
 605             {
 606                 OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( _rxElement, true ) : xHelper->getBindingName( _rxElement, true );
 607                 Reference< xforms::XModel > xModel( xHelper, UNO_QUERY_THROW );
 608                 sUIName = composeModelElementUIName( xModel->getID(), sElementName );
 609             }
 610         }
 611         catch( const Exception& )
 612         {
 613             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getModelElementUIName" );
 614         }
 615
 616         return sUIName;
 617     }
 618
 619
 620     Reference< XPropertySet > EFormsHelper::getModelElementFromUIName( const EFormsHelper::ModelElementType _eType, const OUString& _rUIName ) const
 621     {
 622         const MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames );
 623         MapStringToPropertySet::const_iterator pos = rMapUINameToElement.find( _rUIName );
 624         OSL_ENSURE( pos != rMapUINameToElement.end(), "EFormsHelper::getModelElementFromUIName: didn't find it!" );
 625
 626         return ( pos != rMapUINameToElement.end() ) ? pos->second : Reference< XPropertySet >();
 627     }
 628
 629
 630     void EFormsHelper::getAllElementUINames( const ModelElementType _eType, std::vector< OUString >& /* [out] */ _rElementNames, bool _bPrepentEmptyEntry )
 631     {
 632         MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames );
 633         rMapUINameToElement.clear();
 634         _rElementNames.resize( 0 );
 635
 636         if ( _bPrepentEmptyEntry )
 637             rMapUINameToElement[ OUString() ].clear();
 638
 639         try
 640         {
 641             // obtain the model names
 642             std::vector< OUString > aModels;
 643             getFormModelNames( aModels );
 644             _rElementNames.reserve( aModels.size() * 2 );    // heuristics
 645
 646             // for every model, obtain the element
 647             for (auto const& modelName : aModels)
 648             {
 649                 Reference< xforms::XModel > xModel = getFormModelByName(modelName);
 650                 OSL_ENSURE( xModel.is(), "EFormsHelper::getAllElementUINames: inconsistency in the models!" );
 651                 Reference< xforms::XFormsUIHelper1 > xHelper( xModel, UNO_QUERY );
 652
 653                 Reference< XIndexAccess > xElements;
 654                 if ( xModel.is() )
 655                     xElements.set(( _eType == Submission ) ? xModel->getSubmissions() : xModel->getBindings(), css::uno::UNO_QUERY);
 656                 if ( !xElements.is() )
 657                     break;
 658
 659                 sal_Int32 nElementCount = xElements->getCount();
 660                 for ( sal_Int32 i = 0; i < nElementCount; ++i )
 661                 {
 662                     Reference< XPropertySet > xElement( xElements->getByIndex( i ), UNO_QUERY );
 663                     OSL_ENSURE( xElement.is(), "EFormsHelper::getAllElementUINames: empty element!" );
 664                     if ( !xElement.is() )
 665                         continue;
 666 #if OSL_DEBUG_LEVEL > 0
 667                     {
 668                         Reference< xforms::XModel > xElementsModel;
 669                         xElement->getPropertyValue( PROPERTY_MODEL ) >>= xElementsModel;
 670                         OSL_ENSURE( xElementsModel == xModel, "EFormsHelper::getAllElementUINames: inconsistency in the model-element relationship!" );
 671                         if ( xElementsModel != xModel )
 672                             xElement->setPropertyValue( PROPERTY_MODEL, Any( xModel ) );
 673                     }
 674 #endif
 675                     OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( xElement, true ) : xHelper->getBindingName( xElement, true );
 676                     OUString sUIName = composeModelElementUIName( modelName, sElementName );
 677
 678                     OSL_ENSURE( rMapUINameToElement.find( sUIName ) == rMapUINameToElement.end(), "EFormsHelper::getAllElementUINames: duplicate name!" );
 679                     rMapUINameToElement.emplace( sUIName, xElement );
 680                 }
 681             }
 682         }
 683         catch( const Exception& )
 684         {
 685             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::getAllElementUINames" );
 686         }
 687
 688         _rElementNames.resize( rMapUINameToElement.size() );
 689         std::transform( rMapUINameToElement.begin(), rMapUINameToElement.end(), _rElementNames.begin(),
 690                 ::o3tl::select1st< MapStringToPropertySet::value_type >() );
 691     }
 692
 693
 694     void EFormsHelper::firePropertyChange( const OUString& _rName, const Any& _rOldValue, const Any& _rNewValue ) const
 695     {
 696         if ( m_aPropertyListeners.getLength() == 0 )
 697             return;
 698
 699         if ( _rOldValue == _rNewValue )
 700             return;
 701
 702         try
 703         {
 704             PropertyChangeEvent aEvent;
 705
 706             aEvent.Source = m_xBindableControl.get();
 707             aEvent.PropertyName = _rName;
 708             aEvent.OldValue = _rOldValue;
 709             aEvent.NewValue = _rNewValue;
 710
 711             const_cast< EFormsHelper* >( this )->m_aPropertyListeners.notifyEach( &XPropertyChangeListener::propertyChange, aEvent );
 712         }
 713         catch( const Exception& )
 714         {
 715             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::firePropertyChange" );
 716         }
 717     }
 718
 719
 720     void EFormsHelper::firePropertyChanges( const Reference< XPropertySet >& _rxOldProps, const Reference< XPropertySet >& _rxNewProps, std::set< OUString >& _rFilter ) const
 721     {
 722         if ( m_aPropertyListeners.getLength() == 0 )
 723             return;
 724
 725         try
 726         {
 727             PropertyBag aProperties;
 728             Reference< XPropertySetInfo > xOldInfo = collectPropertiesGetInfo( _rxOldProps, aProperties );
 729             Reference< XPropertySetInfo > xNewInfo = collectPropertiesGetInfo( _rxNewProps, aProperties );
 730
 731             for (auto const& property : aProperties)
 732             {
 733                 if ( _rFilter.find( property.Name ) != _rFilter.end() )
 734                     continue;
 735
 736                 Any aOldValue( nullptr, property.Type );
 737                 if ( xOldInfo.is() && xOldInfo->hasPropertyByName( property.Name ) )
 738                     aOldValue = _rxOldProps->getPropertyValue( property.Name );
 739
 740                 Any aNewValue( nullptr, property.Type );
 741                 if ( xNewInfo.is() && xNewInfo->hasPropertyByName( property.Name ) )
 742                     aNewValue = _rxNewProps->getPropertyValue( property.Name );
 743
 744                 firePropertyChange( property.Name, aOldValue, aNewValue );
 745             }
 746         }
 747         catch( const Exception& )
 748         {
 749             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "EFormsHelper::firePropertyChanges" );
 750         }
 751     }
 752
 753
 754 } // namespace pcr
 755
 756
 757 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */