extensions/source/propctrlr/eformspropertyhandler.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 "eformspropertyhandler.hxx"
  21 #include "formstrings.hxx"
  22 #include "formmetadata.hxx"
  23 #include "pcrservices.hxx"
  24 #include <propctrlr.h>
  25 #include "formbrowsertools.hxx"
  26 #include "eformshelper.hxx"
  27 #include "handlerhelper.hxx"
  28
  29 #include <com/sun/star/lang/NullPointerException.hpp>
  30 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  31 #include <com/sun/star/inspection/PropertyControlType.hpp>
  32 #include <com/sun/star/inspection/XObjectInspectorUI.hpp>
  33 #include <tools/debug.hxx>
  34 #include <tools/diagnose_ex.h>
  35 #include <sal/log.hxx>
  36
  37 #include <functional>
  38
  39
  40 extern "C" void createRegistryInfo_EFormsPropertyHandler()
  41 {
  42     ::pcr::EFormsPropertyHandler::registerImplementation();
  43 }
  44
  45
  46 namespace pcr
  47 {
  48
  49
  50     using namespace ::com::sun::star;
  51     using namespace ::com::sun::star::uno;
  52     using namespace ::com::sun::star::lang;
  53     using namespace ::com::sun::star::beans;
  54     using namespace ::com::sun::star::xforms;
  55     using namespace ::com::sun::star::script;
  56     using namespace ::com::sun::star::ui::dialogs;
  57     using namespace ::com::sun::star::form::binding;
  58     using namespace ::com::sun::star::inspection;
  59
  60
  61     //= EFormsPropertyHandler
  62
  63
  64     EFormsPropertyHandler::EFormsPropertyHandler( const Reference< XComponentContext >& _rxContext )
  65         :EFormsPropertyHandler_Base( _rxContext )
  66         ,m_bSimulatingModelChange( false )
  67     {
  68     }
  69
  70
  71     EFormsPropertyHandler::~EFormsPropertyHandler( )
  72     {
  73     }
  74
  75
  76     OUString EFormsPropertyHandler::getImplementationName_static(  )
  77     {
  78         return OUString( "com.sun.star.comp.extensions.EFormsPropertyHandler" );
  79     }
  80
  81
  82     Sequence< OUString > EFormsPropertyHandler::getSupportedServiceNames_static(  )
  83     {
  84         Sequence<OUString> aSupported { "com.sun.star.form.inspection.XMLFormsPropertyHandler" };
  85         return aSupported;
  86     }
  87
  88
  89     OUString EFormsPropertyHandler::getModelNamePropertyValue() const
  90     {
  91         OUString sModelName = m_pHelper->getCurrentFormModelName();
  92         if ( sModelName.isEmpty() )
  93             sModelName = m_sBindingLessModelName;
  94         return sModelName;
  95     }
  96
  97
  98     Any SAL_CALL EFormsPropertyHandler::getPropertyValue( const OUString& _rPropertyName )
  99     {
 100         ::osl::MutexGuard aGuard( m_aMutex );
 101         PropertyId nPropId( impl_getPropertyId_throwUnknownProperty( _rPropertyName ) );
 102
 103         OSL_ENSURE(
 104             m_pHelper,
 105             "EFormsPropertyHandler::getPropertyValue: we don't have any SupportedProperties!");
 106         // if we survived impl_getPropertyId_throwUnknownProperty, we should have a helper, since no helper implies no properties
 107
 108         Any aReturn;
 109         try
 110         {
 111             switch ( nPropId )
 112             {
 113             case PROPERTY_ID_LIST_BINDING:
 114                 aReturn <<= m_pHelper->getCurrentListSourceBinding();
 115                 break;
 116
 117             case PROPERTY_ID_XML_DATA_MODEL:
 118                 aReturn <<= getModelNamePropertyValue();
 119                 break;
 120
 121             case PROPERTY_ID_BINDING_NAME:
 122                 aReturn <<= m_pHelper->getCurrentBindingName();
 123                 break;
 124
 125             case PROPERTY_ID_BIND_EXPRESSION:
 126             case PROPERTY_ID_XSD_CONSTRAINT:
 127             case PROPERTY_ID_XSD_CALCULATION:
 128             case PROPERTY_ID_XSD_REQUIRED:
 129             case PROPERTY_ID_XSD_RELEVANT:
 130             case PROPERTY_ID_XSD_READONLY:
 131             {
 132                 Reference< XPropertySet > xBindingProps( m_pHelper->getCurrentBinding() );
 133                 if ( xBindingProps.is() )
 134                 {
 135                     aReturn = xBindingProps->getPropertyValue( _rPropertyName );
 136                     DBG_ASSERT( aReturn.getValueType().equals( ::cppu::UnoType<OUString>::get() ),
 137                         "EFormsPropertyHandler::getPropertyValue: invalid BindingExpression value type!" );
 138                 }
 139                 else
 140                     aReturn <<= OUString();
 141             }
 142             break;
 143
 144             default:
 145                 OSL_FAIL( "EFormsPropertyHandler::getPropertyValue: cannot handle this property!" );
 146                 break;
 147             }
 148         }
 149         catch( const Exception& )
 150         {
 151             css::uno::Any ex( cppu::getCaughtException() );
 152             SAL_WARN( "extensions.propctrlr", "EFormsPropertyHandler::getPropertyValue: caught an exception!"
 153                 "\n(have been asked for the \"" <<_rPropertyName << "\" property.) " << exceptionToString(ex));
 154         }
 155         return aReturn;
 156     }
 157
 158
 159     void SAL_CALL EFormsPropertyHandler::setPropertyValue( const OUString& _rPropertyName, const Any& _rValue )
 160     {
 161         ::osl::MutexGuard aGuard( m_aMutex );
 162         PropertyId nPropId( impl_getPropertyId_throwUnknownProperty( _rPropertyName ) );
 163
 164         OSL_ENSURE(
 165             m_pHelper,
 166             "EFormsPropertyHandler::setPropertyValue: we don't have any SupportedProperties!");
 167         // if we survived impl_getPropertyId_throwUnknownProperty, we should have a helper, since no helper implies no properties
 168
 169         try
 170         {
 171             Any aOldValue = getPropertyValue( _rPropertyName );
 172
 173             switch ( nPropId )
 174             {
 175             case PROPERTY_ID_LIST_BINDING:
 176             {
 177                 Reference< XListEntrySource > xSource;
 178                 OSL_VERIFY( _rValue >>= xSource );
 179                 m_pHelper->setListSourceBinding( xSource );
 180             }
 181             break;
 182
 183             case PROPERTY_ID_XML_DATA_MODEL:
 184             {
 185                 OSL_VERIFY( _rValue >>= m_sBindingLessModelName );
 186
 187                 // if the model changed, reset the binding to NULL
 188                 if ( m_pHelper->getCurrentFormModelName() != m_sBindingLessModelName )
 189                 {
 190                     OUString sOldBindingName = m_pHelper->getCurrentBindingName();
 191                     m_pHelper->setBinding( nullptr );
 192                     firePropertyChange( PROPERTY_BINDING_NAME, PROPERTY_ID_BINDING_NAME,
 193                         makeAny( sOldBindingName ), makeAny( OUString() ) );
 194                 }
 195             }
 196             break;
 197
 198             case PROPERTY_ID_BINDING_NAME:
 199             {
 200                 OUString sNewBindingName;
 201                 OSL_VERIFY( _rValue >>= sNewBindingName );
 202
 203                 bool bPreviouslyEmptyModel = !m_pHelper->getCurrentFormModel().is();
 204
 205                 Reference< XPropertySet > xNewBinding;
 206                 if ( !sNewBindingName.isEmpty() )
 207                     // obtain the binding with this name, for the current model
 208                     xNewBinding = m_pHelper->getOrCreateBindingForModel( getModelNamePropertyValue(), sNewBindingName );
 209
 210                 m_pHelper->setBinding( xNewBinding );
 211
 212                 if ( bPreviouslyEmptyModel )
 213                 {   // simulate a property change for the model property
 214                     // This is because we "simulate" the Model property by remembering the
 215                     // value ourself. Other instances might, however, not know this value,
 216                     // but prefer to retrieve it somewhere else - e.g. from the EFormsHelper
 217
 218                     // The really correct solution would be if *all* property handlers
 219                     // obtain a "current property value" for *all* properties from a central
 220                     // instance. Then, handler A could ask it for the value of property
 221                     // X, and this request would be re-routed to handler B, which ultimately
 222                     // knows the current value.
 223                     // However, there's no such mechanism in place currently.
 224                     m_bSimulatingModelChange = true;
 225                     firePropertyChange( PROPERTY_XML_DATA_MODEL, PROPERTY_ID_XML_DATA_MODEL,
 226                         makeAny( OUString() ), makeAny( getModelNamePropertyValue() ) );
 227                     m_bSimulatingModelChange = false;
 228                 }
 229             }
 230             break;
 231
 232             case PROPERTY_ID_BIND_EXPRESSION:
 233             {
 234                 Reference< XPropertySet > xBinding( m_pHelper->getCurrentBinding() );
 235                 OSL_ENSURE( xBinding.is(), "You should not reach this without an active binding!" );
 236                 if ( xBinding.is() )
 237                     xBinding->setPropertyValue( PROPERTY_BIND_EXPRESSION, _rValue );
 238             }
 239             break;
 240
 241             case PROPERTY_ID_XSD_REQUIRED:
 242             case PROPERTY_ID_XSD_RELEVANT:
 243             case PROPERTY_ID_XSD_READONLY:
 244             case PROPERTY_ID_XSD_CONSTRAINT:
 245             case PROPERTY_ID_XSD_CALCULATION:
 246             {
 247                 Reference< XPropertySet > xBindingProps( m_pHelper->getCurrentBinding() );
 248                 DBG_ASSERT( xBindingProps.is(), "EFormsPropertyHandler::setPropertyValue: how can I set a property if there's no binding?" );
 249                 if ( xBindingProps.is() )
 250                 {
 251                     DBG_ASSERT( _rValue.getValueType().equals( ::cppu::UnoType<OUString>::get() ),
 252                         "EFormsPropertyHandler::setPropertyValue: invalid value type!" );
 253                     xBindingProps->setPropertyValue( _rPropertyName, _rValue );
 254                 }
 255             }
 256             break;
 257
 258             default:
 259                 OSL_FAIL( "EFormsPropertyHandler::setPropertyValue: cannot handle this property!" );
 260                 break;
 261             }
 262
 263             impl_setContextDocumentModified_nothrow();
 264
 265             Any aNewValue( getPropertyValue( _rPropertyName ) );
 266             firePropertyChange( _rPropertyName, nPropId, aOldValue, aNewValue );
 267         }
 268         catch( const Exception& )
 269         {
 270             OSL_FAIL( "EFormsPropertyHandler::setPropertyValue: caught an exception!" );
 271         }
 272     }
 273
 274
 275     void EFormsPropertyHandler::onNewComponent()
 276     {
 277         EFormsPropertyHandler_Base::onNewComponent();
 278
 279         Reference< frame::XModel > xDocument( impl_getContextDocument_nothrow() );
 280         DBG_ASSERT( xDocument.is(), "EFormsPropertyHandler::onNewComponent: no document!" );
 281         if ( EFormsHelper::isEForm( xDocument ) )
 282             m_pHelper.reset( new EFormsHelper( m_aMutex, m_xComponent, xDocument ) );
 283         else
 284             m_pHelper.reset();
 285     }
 286
 287
 288     Sequence< Property > EFormsPropertyHandler::doDescribeSupportedProperties() const
 289     {
 290         std::vector< Property > aProperties;
 291
 292         if (m_pHelper)
 293         {
 294             if ( m_pHelper->canBindToAnyDataType() )
 295             {
 296                 aProperties.reserve( 7 );
 297                 addStringPropertyDescription( aProperties, PROPERTY_XML_DATA_MODEL );
 298                 addStringPropertyDescription( aProperties, PROPERTY_BINDING_NAME );
 299                 addStringPropertyDescription( aProperties, PROPERTY_BIND_EXPRESSION );
 300                 addStringPropertyDescription( aProperties, PROPERTY_XSD_REQUIRED );
 301                 addStringPropertyDescription( aProperties, PROPERTY_XSD_RELEVANT );
 302                 addStringPropertyDescription( aProperties, PROPERTY_XSD_READONLY );
 303                 addStringPropertyDescription( aProperties, PROPERTY_XSD_CONSTRAINT );
 304                 addStringPropertyDescription( aProperties, PROPERTY_XSD_CALCULATION );
 305             }
 306             if ( m_pHelper->isListEntrySink() )
 307             {
 308                 implAddPropertyDescription( aProperties, PROPERTY_LIST_BINDING,
 309                     cppu::UnoType<XListEntrySource>::get() );
 310             }
 311         }
 312
 313         if ( aProperties.empty() )
 314             return Sequence< Property >();
 315         return comphelper::containerToSequence(aProperties);
 316     }
 317
 318
 319     Any SAL_CALL EFormsPropertyHandler::convertToPropertyValue( const OUString& _rPropertyName, const Any& _rControlValue )
 320     {
 321         ::osl::MutexGuard aGuard( m_aMutex );
 322         Any aReturn;
 323
 324         OSL_ENSURE(
 325             m_pHelper,
 326             "EFormsPropertyHandler::convertToPropertyValue: we have no SupportedProperties!");
 327         if (!m_pHelper)
 328             return aReturn;
 329
 330         PropertyId nPropId( m_pInfoService->getPropertyId( _rPropertyName ) );
 331
 332         OUString sControlValue;
 333         switch ( nPropId )
 334         {
 335         case PROPERTY_ID_LIST_BINDING:
 336         {
 337             OSL_VERIFY( _rControlValue >>= sControlValue );
 338             Reference< XListEntrySource > xListSource( m_pHelper->getModelElementFromUIName( EFormsHelper::Binding, sControlValue ), UNO_QUERY );
 339             OSL_ENSURE( xListSource.is() || !m_pHelper->getModelElementFromUIName( EFormsHelper::Binding, sControlValue ).is(),
 340                 "EFormsPropertyHandler::convertToPropertyValue: there's a binding which is no ListEntrySource!" );
 341             aReturn <<= xListSource;
 342         }
 343         break;
 344
 345         default:
 346             aReturn = EFormsPropertyHandler_Base::convertToPropertyValue( _rPropertyName, _rControlValue );
 347             break;
 348         }
 349
 350         return aReturn;
 351     }
 352
 353
 354     Any SAL_CALL EFormsPropertyHandler::convertToControlValue( const OUString& _rPropertyName, const Any& _rPropertyValue, const Type& _rControlValueType )
 355     {
 356         ::osl::MutexGuard aGuard( m_aMutex );
 357         Any aReturn;
 358
 359         OSL_ENSURE(m_pHelper,
 360                    "EFormsPropertyHandler::convertToControlValue: we have no SupportedProperties!");
 361         if (!m_pHelper)
 362             return aReturn;
 363
 364         PropertyId nPropId( m_pInfoService->getPropertyId( _rPropertyName ) );
 365
 366         OSL_ENSURE( _rControlValueType.getTypeClass() == TypeClass_STRING,
 367             "EFormsPropertyHandler::convertToControlValue: all our controls should use strings for value exchange!" );
 368
 369         switch ( nPropId )
 370         {
 371         case PROPERTY_ID_LIST_BINDING:
 372         {
 373             Reference< XPropertySet > xListSourceBinding( _rPropertyValue, UNO_QUERY );
 374             if ( xListSourceBinding.is() )
 375                 aReturn <<= EFormsHelper::getModelElementUIName( EFormsHelper::Binding, xListSourceBinding );
 376         }
 377         break;
 378
 379         default:
 380             aReturn = EFormsPropertyHandler_Base::convertToControlValue( _rPropertyName, _rPropertyValue, _rControlValueType );
 381             break;
 382         }
 383
 384         return aReturn;
 385     }
 386
 387
 388     Sequence< OUString > SAL_CALL EFormsPropertyHandler::getActuatingProperties( )
 389     {
 390         ::osl::MutexGuard aGuard( m_aMutex );
 391         if (!m_pHelper)
 392             return Sequence< OUString >();
 393
 394         std::vector< OUString > aInterestedInActuations( 2 );
 395         aInterestedInActuations[ 0 ] = PROPERTY_XML_DATA_MODEL;
 396         aInterestedInActuations[ 1 ] = PROPERTY_BINDING_NAME;
 397         return comphelper::containerToSequence(aInterestedInActuations);
 398     }
 399
 400
 401     Sequence< OUString > SAL_CALL EFormsPropertyHandler::getSupersededProperties( )
 402     {
 403         ::osl::MutexGuard aGuard( m_aMutex );
 404         if (!m_pHelper)
 405             return Sequence< OUString >();
 406
 407         Sequence<OUString> aReturn { PROPERTY_INPUT_REQUIRED };
 408         return aReturn;
 409     }
 410
 411
 412     LineDescriptor SAL_CALL EFormsPropertyHandler::describePropertyLine( const OUString& _rPropertyName,
 413         const Reference< XPropertyControlFactory >& _rxControlFactory )
 414     {
 415         ::osl::MutexGuard aGuard( m_aMutex );
 416         if ( !_rxControlFactory.is() )
 417             throw NullPointerException();
 418         if (!m_pHelper)
 419             throw RuntimeException();
 420
 421         LineDescriptor aDescriptor;
 422         sal_Int16 nControlType = PropertyControlType::TextField;
 423         std::vector< OUString > aListEntries;
 424         PropertyId nPropId( impl_getPropertyId_throwUnknownProperty( _rPropertyName ) );
 425         switch ( nPropId )
 426         {
 427         case PROPERTY_ID_LIST_BINDING:
 428             nControlType = PropertyControlType::ListBox;
 429             m_pHelper->getAllElementUINames(EFormsHelper::Binding, aListEntries, true);
 430             break;
 431
 432         case PROPERTY_ID_XML_DATA_MODEL:
 433             nControlType = PropertyControlType::ListBox;
 434             m_pHelper->getFormModelNames( aListEntries );
 435             break;
 436
 437         case PROPERTY_ID_BINDING_NAME:
 438         {
 439             nControlType = PropertyControlType::ComboBox;
 440             OUString sCurrentModel( getModelNamePropertyValue() );
 441             if ( !sCurrentModel.isEmpty() )
 442                 m_pHelper->getBindingNames( sCurrentModel, aListEntries );
 443         }
 444         break;
 445
 446         case PROPERTY_ID_BIND_EXPRESSION:   aDescriptor.PrimaryButtonId = UID_PROP_DLG_BIND_EXPRESSION; break;
 447         case PROPERTY_ID_XSD_REQUIRED:      aDescriptor.PrimaryButtonId = UID_PROP_DLG_XSD_REQUIRED;    break;
 448         case PROPERTY_ID_XSD_RELEVANT:      aDescriptor.PrimaryButtonId = UID_PROP_DLG_XSD_RELEVANT;    break;
 449         case PROPERTY_ID_XSD_READONLY:      aDescriptor.PrimaryButtonId = UID_PROP_DLG_XSD_READONLY;    break;
 450         case PROPERTY_ID_XSD_CONSTRAINT:    aDescriptor.PrimaryButtonId = UID_PROP_DLG_XSD_CONSTRAINT;  break;
 451         case PROPERTY_ID_XSD_CALCULATION:   aDescriptor.PrimaryButtonId = UID_PROP_DLG_XSD_CALCULATION; break;
 452
 453         default:
 454             OSL_FAIL( "EFormsPropertyHandler::describePropertyLine: cannot handle this property!" );
 455             break;
 456         }
 457
 458         switch ( nControlType )
 459         {
 460         case PropertyControlType::ListBox:
 461             aDescriptor.Control = PropertyHandlerHelper::createListBoxControl( _rxControlFactory, aListEntries, false, true );
 462             break;
 463         case PropertyControlType::ComboBox:
 464             aDescriptor.Control = PropertyHandlerHelper::createComboBoxControl( _rxControlFactory, aListEntries, true );
 465             break;
 466         default:
 467             aDescriptor.Control = _rxControlFactory->createPropertyControl( nControlType, false );
 468             break;
 469         }
 470
 471         aDescriptor.DisplayName = m_pInfoService->getPropertyTranslation( nPropId );
 472         aDescriptor.Category = "Data";
 473         aDescriptor.HelpURL = HelpIdUrl::getHelpURL( m_pInfoService->getPropertyHelpId( nPropId ) );
 474         return aDescriptor;
 475     }
 476
 477
 478     InteractiveSelectionResult SAL_CALL EFormsPropertyHandler::onInteractivePropertySelection( const OUString& _rPropertyName, sal_Bool /*_bPrimary*/, Any& _rData, const Reference< XObjectInspectorUI >& _rxInspectorUI )
 479     {
 480         if ( !_rxInspectorUI.is() )
 481             throw NullPointerException();
 482
 483         ::osl::MutexGuard aGuard( m_aMutex );
 484         OSL_ENSURE(m_pHelper, "EFormsPropertyHandler::onInteractivePropertySelection: we do not "
 485                               "have any SupportedProperties!");
 486         if (!m_pHelper)
 487             return InteractiveSelectionResult_Cancelled;
 488
 489         PropertyId nPropId( impl_getPropertyId_throwUnknownProperty( _rPropertyName ) );
 490         OSL_ENSURE( ( PROPERTY_ID_BINDING_NAME == nPropId )
 491                  || ( PROPERTY_ID_BIND_EXPRESSION == nPropId )
 492                  || ( PROPERTY_ID_XSD_REQUIRED == nPropId )
 493                  || ( PROPERTY_ID_XSD_RELEVANT == nPropId )
 494                  || ( PROPERTY_ID_XSD_READONLY == nPropId )
 495                  || ( PROPERTY_ID_XSD_CONSTRAINT == nPropId )
 496                  || ( PROPERTY_ID_XSD_CALCULATION == nPropId ), "EFormsPropertyHandler::onInteractivePropertySelection: unexpected!" );
 497
 498         try
 499         {
 500             Reference< XExecutableDialog > xDialog;
 501             xDialog.set( m_xContext->getServiceManager()->createInstanceWithContext( "com.sun.star.xforms.ui.dialogs.AddCondition", m_xContext ), UNO_QUERY );
 502             Reference< XPropertySet > xDialogProps( xDialog, UNO_QUERY_THROW );
 503
 504             // the model for the dialog to work with
 505             Reference< xforms::XModel > xModel( m_pHelper->getCurrentFormModel() );
 506             // the binding for the dialog to work with
 507             Reference< XPropertySet > xBinding( m_pHelper->getCurrentBinding() );
 508             // the aspect of the binding which the dialog should modify
 509             const OUString& sFacetName( _rPropertyName );
 510
 511             OSL_ENSURE( xModel.is() && xBinding.is() && !sFacetName.isEmpty(),
 512                 "EFormsPropertyHandler::onInteractivePropertySelection: something is missing for the dialog initialization!" );
 513             if ( !( xModel.is() && xBinding.is() && !sFacetName.isEmpty() ) )
 514                 return InteractiveSelectionResult_Cancelled;
 515
 516             xDialogProps->setPropertyValue("FormModel", makeAny( xModel ) );
 517             xDialogProps->setPropertyValue("Binding", makeAny( xBinding ) );
 518             xDialogProps->setPropertyValue("FacetName", makeAny( sFacetName ) );
 519
 520             if ( !xDialog->execute() )
 521                 // cancelled
 522                 return InteractiveSelectionResult_Cancelled;
 523
 524             _rData = xDialogProps->getPropertyValue("ConditionValue");
 525             return InteractiveSelectionResult_ObtainedValue;
 526         }
 527         catch( const Exception& )
 528         {
 529             OSL_FAIL( "EFormsPropertyHandler::onInteractivePropertySelection: caught an exception!" );
 530         }
 531
 532         // something went wrong here ...(but has been asserted already)
 533         return InteractiveSelectionResult_Cancelled;
 534     }
 535
 536
 537     void SAL_CALL EFormsPropertyHandler::addPropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener )
 538     {
 539         ::osl::MutexGuard aGuard( m_aMutex );
 540         EFormsPropertyHandler_Base::addPropertyChangeListener( _rxListener );
 541         if (m_pHelper)
 542             m_pHelper->registerBindingListener( _rxListener );
 543     }
 544
 545
 546     void SAL_CALL EFormsPropertyHandler::removePropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener )
 547     {
 548         ::osl::MutexGuard aGuard( m_aMutex );
 549         if (m_pHelper)
 550             m_pHelper->revokeBindingListener( _rxListener );
 551         EFormsPropertyHandler_Base::removePropertyChangeListener( _rxListener );
 552     }
 553
 554
 555     void SAL_CALL EFormsPropertyHandler::actuatingPropertyChanged( const OUString& _rActuatingPropertyName, const Any& _rNewValue, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& _rxInspectorUI, sal_Bool )
 556     {
 557         if ( !_rxInspectorUI.is() )
 558             throw NullPointerException();
 559
 560         ::osl::MutexGuard aGuard( m_aMutex );
 561         PropertyId nActuatingPropId( impl_getPropertyId_throwRuntime( _rActuatingPropertyName ) );
 562         OSL_PRECOND(m_pHelper, "EFormsPropertyHandler::actuatingPropertyChanged: inconsistentcy!");
 563         // if we survived impl_getPropertyId_throwRuntime, we should have a helper, since no helper implies no properties
 564
 565         DBG_ASSERT( _rxInspectorUI.is(), "EFormsPropertyHandler::actuatingPropertyChanged: invalid callback!" );
 566         if ( !_rxInspectorUI.is() )
 567             return;
 568
 569         switch ( nActuatingPropId )
 570         {
 571         case PROPERTY_ID_XML_DATA_MODEL:
 572         {
 573             if ( m_bSimulatingModelChange )
 574                 break;
 575             OUString sDataModelName;
 576             OSL_VERIFY( _rNewValue >>= sDataModelName );
 577             bool bBoundToSomeModel = !sDataModelName.isEmpty();
 578             _rxInspectorUI->rebuildPropertyUI( PROPERTY_BINDING_NAME );
 579             _rxInspectorUI->enablePropertyUI( PROPERTY_BINDING_NAME, bBoundToSomeModel );
 580             [[fallthrough]];
 581         }
 582
 583         case PROPERTY_ID_BINDING_NAME:
 584         {
 585             bool bHaveABinding = !m_pHelper->getCurrentBindingName().isEmpty();
 586             _rxInspectorUI->enablePropertyUI( PROPERTY_BIND_EXPRESSION, bHaveABinding );
 587             _rxInspectorUI->enablePropertyUI( PROPERTY_XSD_REQUIRED, bHaveABinding );
 588             _rxInspectorUI->enablePropertyUI( PROPERTY_XSD_RELEVANT, bHaveABinding );
 589             _rxInspectorUI->enablePropertyUI( PROPERTY_XSD_READONLY, bHaveABinding );
 590             _rxInspectorUI->enablePropertyUI( PROPERTY_XSD_CONSTRAINT, bHaveABinding );
 591             _rxInspectorUI->enablePropertyUI( PROPERTY_XSD_CALCULATION, bHaveABinding );
 592             _rxInspectorUI->enablePropertyUI( PROPERTY_XSD_DATA_TYPE, bHaveABinding );
 593         }
 594         break;
 595
 596         default:
 597             OSL_FAIL( "EFormsPropertyHandler::actuatingPropertyChanged: cannot handle this property!" );
 598             break;
 599         }
 600     }
 601
 602
 603 } // namespace pcr
 604
 605
 606 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */