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