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