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 <memory>
  21 #include "eformshelper.hxx"
  22 #include "formstrings.hxx"
  23 #include <strings.hrc>
  24 #include "modulepcr.hxx"
  25 #include "propeventtranslation.hxx"
  26 #include "formbrowsertools.hxx"
  27
  28 #include <com/sun/star/lang/XServiceInfo.hpp>
  29 #include <com/sun/star/form/FormComponentType.hpp>
  30 #include <com/sun/star/xforms/XFormsUIHelper1.hpp>
  31 #include <com/sun/star/xsd/DataTypeClass.hpp>
  32 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  33 #include <tools/diagnose_ex.h>
  34 #include <rtl/ustrbuf.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( const OUString& _rModelName, const OUString& _rElementName )
  59         {
  60             OUString a = "["
  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             OSL_FAIL( "EFormsHelper::isEForm: caught an exception!" );
  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             OSL_FAIL( "EFormsHelper::canBindToDataType: caught an exception!" );
 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             OSL_FAIL( "EFormsHelper::isListEntrySink: caught an exception!" );
 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             std::unique_ptr< ::comphelper::OInterfaceIteratorHelper2 > pListenerIterator = m_aPropertyListeners.createIterator();
 244             while ( pListenerIterator->hasMoreElements() )
 245             {
 246                 PropertyEventTranslation* pTranslator = dynamic_cast< PropertyEventTranslation* >( pListenerIterator->next() );
 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.removeListener( 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.addListener( xEventSourceTranslator );
 273                 impl_switchBindingListening_throw( true, xEventSourceTranslator );
 274             }
 275             else
 276             {
 277                 std::unique_ptr< ::comphelper::OInterfaceIteratorHelper2 > pListenerIterator = m_aPropertyListeners.createIterator();
 278                 while ( pListenerIterator->hasMoreElements() )
 279                 {
 280                     Reference< XPropertyChangeListener > xListener( pListenerIterator->next(), UNO_QUERY );
 281                     impl_switchBindingListening_throw( true, xListener );
 282                 }
 283             }
 284         }
 285     }
 286
 287
 288     void EFormsHelper::revokeBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener )
 289     {
 290         impl_toggleBindingPropertyListening_throw( false, _rxBindingListener );
 291     }
 292
 293
 294     void EFormsHelper::getFormModelNames( std::vector< OUString >& /* [out] */ _rModelNames ) const
 295     {
 296         if ( m_xDocument.is() )
 297         {
 298             try
 299             {
 300                 _rModelNames.resize( 0 );
 301
 302                 Reference< XNameContainer > xForms( m_xDocument->getXForms() );
 303                 OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelNames: invalid forms container!" );
 304                 if ( xForms.is() )
 305                 {
 306                     Sequence< OUString > aModelNames = xForms->getElementNames();
 307                     _rModelNames.resize( aModelNames.getLength() );
 308                     std::copy( aModelNames.begin(), aModelNames.end(), _rModelNames.begin() );
 309                 }
 310             }
 311             catch( const Exception& )
 312             {
 313                 OSL_FAIL( "EFormsHelper::getFormModelNames: caught an exception!" );
 314             }
 315         }
 316     }
 317
 318
 319     void EFormsHelper::getBindingNames( const OUString& _rModelName, std::vector< OUString >& /* [out] */ _rBindingNames ) const
 320     {
 321         _rBindingNames.resize( 0 );
 322         try
 323         {
 324             Reference< xforms::XModel > xModel( getFormModelByName( _rModelName ) );
 325             if ( xModel.is() )
 326             {
 327                 Reference< XNameAccess > xBindings( xModel->getBindings(), UNO_QUERY );
 328                 OSL_ENSURE( xBindings.is(), "EFormsHelper::getBindingNames: invalid bindings container obtained from the model!" );
 329                 if ( xBindings.is() )
 330                 {
 331                     Sequence< OUString > aNames = xBindings->getElementNames();
 332                     _rBindingNames.resize( aNames.getLength() );
 333                     std::copy( aNames.begin(), aNames.end(), _rBindingNames.begin() );
 334                 }
 335             }
 336         }
 337         catch( const Exception& )
 338         {
 339             OSL_FAIL( "EFormsHelper::getBindingNames: caught an exception!" );
 340         }
 341     }
 342
 343
 344     Reference< xforms::XModel > EFormsHelper::getFormModelByName( const OUString& _rModelName ) const
 345     {
 346         Reference< xforms::XModel > xReturn;
 347         try
 348         {
 349             Reference< XNameContainer > xForms( m_xDocument->getXForms() );
 350             OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelByName: invalid forms container!" );
 351             if ( xForms.is() )
 352                 OSL_VERIFY( xForms->getByName( _rModelName ) >>= xReturn );
 353         }
 354         catch( const Exception& )
 355         {
 356             OSL_FAIL( "EFormsHelper::getFormModelByName: caught an exception!" );
 357         }
 358         return xReturn;
 359     }
 360
 361
 362     Reference< xforms::XModel > EFormsHelper::getCurrentFormModel() const
 363     {
 364         Reference< xforms::XModel > xModel;
 365         try
 366         {
 367             Reference< XPropertySet > xBinding( getCurrentBinding() );
 368             if ( xBinding.is() )
 369             {
 370                 OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_MODEL ) >>= xModel );
 371             }
 372         }
 373         catch( const Exception& )
 374         {
 375             OSL_FAIL( "EFormsHelper::getCurrentFormModel: caught an exception!" );
 376         }
 377         return xModel;
 378     }
 379
 380
 381     OUString EFormsHelper::getCurrentFormModelName() const
 382     {
 383         OUString sModelName;
 384         try
 385         {
 386             Reference< xforms::XModel > xFormsModel( getCurrentFormModel() );
 387             if ( xFormsModel.is() )
 388                 sModelName = xFormsModel->getID();
 389         }
 390         catch( const Exception& )
 391         {
 392             OSL_FAIL( "EFormsHelper::getCurrentFormModel: caught an exception!" );
 393         }
 394         return sModelName;
 395     }
 396
 397
 398     Reference< XPropertySet > EFormsHelper::getCurrentBinding() const
 399     {
 400         Reference< XPropertySet > xBinding;
 401
 402         try
 403         {
 404             if ( m_xBindableControl.is() )
 405                 xBinding.set(m_xBindableControl->getValueBinding(), css::uno::UNO_QUERY);
 406         }
 407         catch( const Exception& )
 408         {
 409             OSL_FAIL( "EFormsHelper::getCurrentBinding: caught an exception!" );
 410         }
 411
 412         return xBinding;
 413     }
 414
 415
 416     OUString EFormsHelper::getCurrentBindingName() const
 417     {
 418         OUString sBindingName;
 419         try
 420         {
 421             Reference< XPropertySet > xBinding( getCurrentBinding() );
 422             if ( xBinding.is() )
 423                 xBinding->getPropertyValue( PROPERTY_BINDING_ID ) >>= sBindingName;
 424         }
 425         catch( const Exception& )
 426         {
 427             OSL_FAIL( "EFormsHelper::getCurrentBindingName: caught an exception!" );
 428         }
 429         return sBindingName;
 430     }
 431
 432
 433     Reference< XListEntrySource > EFormsHelper::getCurrentListSourceBinding() const
 434     {
 435         Reference< XListEntrySource > xReturn;
 436         try
 437         {
 438             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
 439             OSL_ENSURE( xAsSink.is(), "EFormsHelper::getCurrentListSourceBinding: you should have used isListEntrySink before!" );
 440             if ( xAsSink.is() )
 441                 xReturn = xAsSink->getListEntrySource();
 442         }
 443         catch( const Exception& )
 444         {
 445             OSL_FAIL( "EFormsHelper::getCurrentListSourceBinding: caught an exception!" );
 446         }
 447         return xReturn;
 448     }
 449
 450
 451     void EFormsHelper::setListSourceBinding( const Reference< XListEntrySource >& _rxListSource )
 452     {
 453         try
 454         {
 455             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
 456             OSL_ENSURE( xAsSink.is(), "EFormsHelper::setListSourceBinding: you should have used isListEntrySink before!" );
 457             if ( xAsSink.is() )
 458                 xAsSink->setListEntrySource( _rxListSource );
 459         }
 460         catch( const Exception& )
 461         {
 462             OSL_FAIL( "EFormsHelper::setListSourceBinding: caught an exception!" );
 463         }
 464     }
 465
 466
 467     void EFormsHelper::setBinding( const Reference< css::beans::XPropertySet >& _rxBinding )
 468     {
 469         if ( !m_xBindableControl.is() )
 470             return;
 471
 472         try
 473         {
 474             Reference< XPropertySet > xOldBinding( m_xBindableControl->getValueBinding(), UNO_QUERY );
 475
 476             Reference< XValueBinding > xBinding( _rxBinding, UNO_QUERY );
 477             OSL_ENSURE( xBinding.is() || !_rxBinding.is(), "EFormsHelper::setBinding: invalid binding!" );
 478
 479             impl_toggleBindingPropertyListening_throw( false, nullptr );
 480             m_xBindableControl->setValueBinding( xBinding );
 481             impl_toggleBindingPropertyListening_throw( true, nullptr );
 482
 483             std::set< OUString > aSet;
 484             firePropertyChanges( xOldBinding, _rxBinding, aSet );
 485         }
 486         catch( const Exception& )
 487         {
 488             OSL_FAIL( "EFormsHelper::setBinding: caught an exception!" );
 489         }
 490     }
 491
 492
 493     Reference< XPropertySet > EFormsHelper::getOrCreateBindingForModel( const OUString& _rTargetModel, const OUString& _rBindingName ) const
 494     {
 495         OSL_ENSURE( !_rBindingName.isEmpty(), "EFormsHelper::getOrCreateBindingForModel: invalid binding name!" );
 496         return implGetOrCreateBinding( _rTargetModel, _rBindingName );
 497     }
 498
 499
 500     Reference< XPropertySet > EFormsHelper::implGetOrCreateBinding( const OUString& _rTargetModel, const OUString& _rBindingName ) const
 501     {
 502         OSL_ENSURE( !( _rTargetModel.isEmpty() && !_rBindingName.isEmpty() ), "EFormsHelper::implGetOrCreateBinding: no model, but a binding name?" );
 503
 504         Reference< XPropertySet > xBinding;
 505         try
 506         {
 507             OUString sTargetModel( _rTargetModel );
 508             // determine the model which the binding should belong to
 509             if ( sTargetModel.isEmpty() )
 510             {
 511                 std::vector< OUString > aModelNames;
 512                 getFormModelNames( aModelNames );
 513                 if ( !aModelNames.empty() )
 514                     sTargetModel = *aModelNames.begin();
 515                 OSL_ENSURE( !sTargetModel.isEmpty(), "EFormsHelper::implGetOrCreateBinding: unable to obtain a default model!" );
 516             }
 517             Reference< xforms::XModel > xModel( getFormModelByName( sTargetModel ) );
 518             Reference< XNameAccess > xBindingNames( xModel.is() ? xModel->getBindings() : Reference< XSet >(), UNO_QUERY );
 519             if ( xBindingNames.is() )
 520             {
 521                 // get or create the binding instance
 522                 if ( !_rBindingName.isEmpty() )
 523                 {
 524                     if ( xBindingNames->hasByName( _rBindingName ) )
 525                         OSL_VERIFY( xBindingNames->getByName( _rBindingName ) >>= xBinding );
 526                     else
 527                     {
 528                         xBinding = xModel->createBinding( );
 529                         if ( xBinding.is() )
 530                         {
 531                             xBinding->setPropertyValue( PROPERTY_BINDING_ID, makeAny( _rBindingName ) );
 532                             xModel->getBindings()->insert( makeAny( xBinding ) );
 533                         }
 534                     }
 535                 }
 536                 else
 537                 {
 538                     xBinding = xModel->createBinding( );
 539                     if ( xBinding.is() )
 540                     {
 541                         // find a nice name for it
 542                         OUString sBaseName(PcrRes(RID_STR_BINDING_NAME) + " ");
 543                         OUString sNewName;
 544                         sal_Int32 nNumber = 1;
 545                         do
 546                         {
 547                             sNewName = sBaseName + OUString::number( nNumber++ );
 548                         }
 549                         while ( xBindingNames->hasByName( sNewName ) );
 550                         Reference< XNamed > xName( xBinding, UNO_QUERY_THROW );
 551                         xName->setName( sNewName );
 552                         // and insert into the model
 553                         xModel->getBindings()->insert( makeAny( xBinding ) );
 554                     }
 555                 }
 556             }
 557         }
 558         catch( const Exception& )
 559         {
 560             DBG_UNHANDLED_EXCEPTION("extensions.propctrlr");
 561         }
 562
 563         return xBinding;
 564     }
 565
 566
 567     namespace
 568     {
 569
 570         struct PropertyBagInserter
 571         {
 572         private:
 573             PropertyBag& m_rProperties;
 574
 575         public:
 576             explicit PropertyBagInserter( PropertyBag& rProperties ) : m_rProperties( rProperties ) { }
 577
 578             void operator()( const Property& _rProp )
 579             {
 580                 m_rProperties.insert( _rProp );
 581             }
 582         };
 583
 584
 585         Reference< XPropertySetInfo > collectPropertiesGetInfo( const Reference< XPropertySet >& _rxProps, PropertyBag& _rBag )
 586         {
 587             Reference< XPropertySetInfo > xInfo;
 588             if ( _rxProps.is() )
 589                 xInfo = _rxProps->getPropertySetInfo();
 590             if ( xInfo.is() )
 591             {
 592                 Sequence< Property > aProperties = xInfo->getProperties();
 593                 std::for_each( aProperties.begin(), aProperties.end(),
 594                     PropertyBagInserter( _rBag )
 595                 );
 596             }
 597             return xInfo;
 598         }
 599     }
 600
 601
 602     OUString EFormsHelper::getModelElementUIName( const EFormsHelper::ModelElementType _eType, const Reference< XPropertySet >& _rxElement )
 603     {
 604         OUString sUIName;
 605         try
 606         {
 607             // determine the model which the element belongs to
 608             Reference< xforms::XFormsUIHelper1 > xHelper;
 609             if ( _rxElement.is() )
 610                 _rxElement->getPropertyValue( PROPERTY_MODEL ) >>= xHelper;
 611             OSL_ENSURE( xHelper.is(), "EFormsHelper::getModelElementUIName: invalid element or model!" );
 612             if ( xHelper.is() )
 613             {
 614                 OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( _rxElement, true ) : xHelper->getBindingName( _rxElement, true );
 615                 Reference< xforms::XModel > xModel( xHelper, UNO_QUERY_THROW );
 616                 sUIName = composeModelElementUIName( xModel->getID(), sElementName );
 617             }
 618         }
 619         catch( const Exception& )
 620         {
 621             OSL_FAIL( "EFormsHelper::getModelElementUIName: caught an exception!" );
 622         }
 623
 624         return sUIName;
 625     }
 626
 627
 628     Reference< XPropertySet > EFormsHelper::getModelElementFromUIName( const EFormsHelper::ModelElementType _eType, const OUString& _rUIName ) const
 629     {
 630         const MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames );
 631         MapStringToPropertySet::const_iterator pos = rMapUINameToElement.find( _rUIName );
 632         OSL_ENSURE( pos != rMapUINameToElement.end(), "EFormsHelper::getModelElementFromUIName: didn't find it!" );
 633
 634         return ( pos != rMapUINameToElement.end() ) ? pos->second : Reference< XPropertySet >();
 635     }
 636
 637
 638     void EFormsHelper::getAllElementUINames( const ModelElementType _eType, std::vector< OUString >& /* [out] */ _rElementNames, bool _bPrepentEmptyEntry )
 639     {
 640         MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames );
 641         rMapUINameToElement.clear();
 642         _rElementNames.resize( 0 );
 643
 644         if ( _bPrepentEmptyEntry )
 645             rMapUINameToElement[ OUString() ].clear();
 646
 647         try
 648         {
 649             // obtain the model names
 650             std::vector< OUString > aModels;
 651             getFormModelNames( aModels );
 652             _rElementNames.reserve( aModels.size() * 2 );    // heuristics
 653
 654             // for every model, obtain the element
 655             for (auto const& modelName : aModels)
 656             {
 657                 Reference< xforms::XModel > xModel = getFormModelByName(modelName);
 658                 OSL_ENSURE( xModel.is(), "EFormsHelper::getAllElementUINames: inconsistency in the models!" );
 659                 Reference< xforms::XFormsUIHelper1 > xHelper( xModel, UNO_QUERY );
 660
 661                 Reference< XIndexAccess > xElements;
 662                 if ( xModel.is() )
 663                     xElements.set(( _eType == Submission ) ? xModel->getSubmissions() : xModel->getBindings(), css::uno::UNO_QUERY);
 664                 if ( !xElements.is() )
 665                     break;
 666
 667                 sal_Int32 nElementCount = xElements->getCount();
 668                 for ( sal_Int32 i = 0; i < nElementCount; ++i )
 669                 {
 670                     Reference< XPropertySet > xElement( xElements->getByIndex( i ), UNO_QUERY );
 671                     OSL_ENSURE( xElement.is(), "EFormsHelper::getAllElementUINames: empty element!" );
 672                     if ( !xElement.is() )
 673                         continue;
 674 #if OSL_DEBUG_LEVEL > 0
 675                     {
 676                         Reference< xforms::XModel > xElementsModel;
 677                         xElement->getPropertyValue( PROPERTY_MODEL ) >>= xElementsModel;
 678                         OSL_ENSURE( xElementsModel == xModel, "EFormsHelper::getAllElementUINames: inconsistency in the model-element relationship!" );
 679                         if ( xElementsModel != xModel )
 680                             xElement->setPropertyValue( PROPERTY_MODEL, makeAny( xModel ) );
 681                     }
 682 #endif
 683                     OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( xElement, true ) : xHelper->getBindingName( xElement, true );
 684                     OUString sUIName = composeModelElementUIName( modelName, sElementName );
 685
 686                     OSL_ENSURE( rMapUINameToElement.find( sUIName ) == rMapUINameToElement.end(), "EFormsHelper::getAllElementUINames: duplicate name!" );
 687                     rMapUINameToElement.emplace( sUIName, xElement );
 688                 }
 689             }
 690         }
 691         catch( const Exception& )
 692         {
 693             OSL_FAIL( "EFormsHelper::getAllElementUINames: caught an exception!" );
 694         }
 695
 696         _rElementNames.resize( rMapUINameToElement.size() );
 697         std::transform( rMapUINameToElement.begin(), rMapUINameToElement.end(), _rElementNames.begin(),
 698                 ::o3tl::select1st< MapStringToPropertySet::value_type >() );
 699     }
 700
 701
 702     void EFormsHelper::firePropertyChange( const OUString& _rName, const Any& _rOldValue, const Any& _rNewValue ) const
 703     {
 704         if ( m_aPropertyListeners.empty() )
 705             return;
 706
 707         if ( _rOldValue == _rNewValue )
 708             return;
 709
 710         try
 711         {
 712             PropertyChangeEvent aEvent;
 713
 714             aEvent.Source = m_xBindableControl.get();
 715             aEvent.PropertyName = _rName;
 716             aEvent.OldValue = _rOldValue;
 717             aEvent.NewValue = _rNewValue;
 718
 719             const_cast< EFormsHelper* >( this )->m_aPropertyListeners.notify( aEvent, &XPropertyChangeListener::propertyChange );
 720         }
 721         catch( const Exception& )
 722         {
 723             OSL_FAIL( "EFormsHelper::firePropertyChange: caught an exception!" );
 724         }
 725     }
 726
 727
 728     void EFormsHelper::firePropertyChanges( const Reference< XPropertySet >& _rxOldProps, const Reference< XPropertySet >& _rxNewProps, std::set< OUString >& _rFilter ) const
 729     {
 730         if ( m_aPropertyListeners.empty() )
 731             return;
 732
 733         try
 734         {
 735             PropertyBag aProperties;
 736             Reference< XPropertySetInfo > xOldInfo = collectPropertiesGetInfo( _rxOldProps, aProperties );
 737             Reference< XPropertySetInfo > xNewInfo = collectPropertiesGetInfo( _rxNewProps, aProperties );
 738
 739             for (auto const& property : aProperties)
 740             {
 741                 if ( _rFilter.find( property.Name ) != _rFilter.end() )
 742                     continue;
 743
 744                 Any aOldValue( nullptr, property.Type );
 745                 if ( xOldInfo.is() && xOldInfo->hasPropertyByName( property.Name ) )
 746                     aOldValue = _rxOldProps->getPropertyValue( property.Name );
 747
 748                 Any aNewValue( nullptr, property.Type );
 749                 if ( xNewInfo.is() && xNewInfo->hasPropertyByName( property.Name ) )
 750                     aNewValue = _rxNewProps->getPropertyValue( property.Name );
 751
 752                 firePropertyChange( property.Name, aOldValue, aNewValue );
 753             }
 754         }
 755         catch( const Exception& )
 756         {
 757             OSL_FAIL( "EFormsHelper::firePropertyChanges: caught an exception!" );
 758         }
 759     }
 760
 761
 762 } // namespace pcr
 763
 764
 765 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */