extensions/source/propctrlr/cellbindinghandler.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_extensions.hxx"
  30 #include "cellbindinghandler.hxx"
  31 #include "formstrings.hxx"
  32 #include "formmetadata.hxx"
  33 #include "cellbindinghelper.hxx"
  34
  35 /** === begin UNO includes === **/
  36 #include <com/sun/star/form/binding/XValueBinding.hpp>
  37 #include <com/sun/star/table/CellAddress.hpp>
  38 #include <com/sun/star/inspection/XObjectInspectorUI.hpp>
  39 /** === end UNO includes === **/
  40 #include <tools/debug.hxx>
  41
  42 //------------------------------------------------------------------------
  43 extern "C" void SAL_CALL createRegistryInfo_CellBindingPropertyHandler()
  44 {
  45     ::pcr::CellBindingPropertyHandler::registerImplementation();
  46 }
  47
  48 //........................................................................
  49 namespace pcr
  50 {
  51 //........................................................................
  52
  53     using namespace ::com::sun::star::uno;
  54     using namespace ::com::sun::star::table;
  55     using namespace ::com::sun::star::lang;
  56     using namespace ::com::sun::star::beans;
  57     using namespace ::com::sun::star::script;
  58     using namespace ::com::sun::star::frame;
  59     using namespace ::com::sun::star::inspection;
  60     using namespace ::com::sun::star::form::binding;
  61     using namespace ::comphelper;
  62
  63     //====================================================================
  64     //= CellBindingPropertyHandler
  65     //====================================================================
  66     DBG_NAME( CellBindingPropertyHandler )
  67     //--------------------------------------------------------------------
  68     CellBindingPropertyHandler::CellBindingPropertyHandler( const Reference< XComponentContext >& _rxContext )
  69         :CellBindingPropertyHandler_Base( _rxContext )
  70         ,m_pCellExchangeConverter( new DefaultEnumRepresentation( *m_pInfoService, ::getCppuType( static_cast< sal_Int16* >( NULL ) ), PROPERTY_ID_CELL_EXCHANGE_TYPE ) )
  71     {
  72         DBG_CTOR( CellBindingPropertyHandler, NULL );
  73     }
  74
  75     //--------------------------------------------------------------------
  76     ::rtl::OUString SAL_CALL CellBindingPropertyHandler::getImplementationName_static(  ) throw (RuntimeException)
  77     {
  78         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.extensions.CellBindingPropertyHandler" ) );
  79     }
  80
  81     //--------------------------------------------------------------------
  82     Sequence< ::rtl::OUString > SAL_CALL CellBindingPropertyHandler::getSupportedServiceNames_static(  ) throw (RuntimeException)
  83     {
  84         Sequence< ::rtl::OUString > aSupported( 1 );
  85         aSupported[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.form.inspection.CellBindingPropertyHandler" ) );
  86         return aSupported;
  87     }
  88
  89     //--------------------------------------------------------------------
  90     void CellBindingPropertyHandler::onNewComponent()
  91     {
  92         PropertyHandlerComponent::onNewComponent();
  93
  94         Reference< XModel > xDocument( impl_getContextDocument_nothrow() );
  95         DBG_ASSERT( xDocument.is(), "CellBindingPropertyHandler::onNewComponent: no document!" );
  96         if ( CellBindingHelper::isSpreadsheetDocument( xDocument ) )
  97             m_pHelper.reset( new CellBindingHelper( m_xComponent, xDocument ) );
  98     }
  99
 100     //--------------------------------------------------------------------
 101     CellBindingPropertyHandler::~CellBindingPropertyHandler( )
 102     {
 103         DBG_DTOR( CellBindingPropertyHandler, NULL );
 104     }
 105
 106     //--------------------------------------------------------------------
 107     Sequence< ::rtl::OUString > SAL_CALL CellBindingPropertyHandler::getActuatingProperties( ) throw (RuntimeException)
 108     {
 109         Sequence< ::rtl::OUString > aInterestingProperties( 3 );
 110         aInterestingProperties[0] = PROPERTY_LIST_CELL_RANGE;
 111         aInterestingProperties[1] = PROPERTY_BOUND_CELL;
 112         aInterestingProperties[2] = PROPERTY_CONTROLSOURCE;
 113         return aInterestingProperties;
 114     }
 115
 116     //--------------------------------------------------------------------
 117     void SAL_CALL CellBindingPropertyHandler::actuatingPropertyChanged( const ::rtl::OUString& _rActuatingPropertyName, const Any& _rNewValue, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& _rxInspectorUI, sal_Bool _bFirstTimeInit ) throw (NullPointerException, RuntimeException)
 118     {
 119         ::osl::MutexGuard aGuard( m_aMutex );
 120         PropertyId nActuatingPropId( impl_getPropertyId_throw( _rActuatingPropertyName ) );
 121         OSL_PRECOND( m_pHelper.get(), "CellBindingPropertyHandler::actuatingPropertyChanged: inconsistentcy!" );
 122             // if we survived impl_getPropertyId_throw, we should have a helper, since no helper implies no properties
 123
 124         OSL_PRECOND( _rxInspectorUI.is(), "FormComponentPropertyHandler::actuatingPropertyChanged: no access to the UI!" );
 125         if ( !_rxInspectorUI.is() )
 126             throw NullPointerException();
 127
 128         ::std::vector< PropertyId > aDependentProperties;
 129
 130         switch ( nActuatingPropId )
 131         {
 132         // ----- BoundCell -----
 133         case PROPERTY_ID_BOUND_CELL:
 134         {
 135             // the SQL-data-binding related properties need to be enabled if and only if
 136             // there is *no* valid cell binding
 137             Reference< XValueBinding > xBinding;
 138             _rNewValue >>= xBinding;
 139
 140             if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_CELL_EXCHANGE_TYPE ) )
 141                 _rxInspectorUI->enablePropertyUI( PROPERTY_CELL_EXCHANGE_TYPE, xBinding.is() );
 142             if ( impl_componentHasProperty_throw( PROPERTY_CONTROLSOURCE ) )
 143                 _rxInspectorUI->enablePropertyUI( PROPERTY_CONTROLSOURCE, !xBinding.is() );
 144
 145             if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_FILTERPROPOSAL ) )
 146                 _rxInspectorUI->enablePropertyUI( PROPERTY_FILTERPROPOSAL, !xBinding.is() );
 147             if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_EMPTY_IS_NULL ) )
 148                 _rxInspectorUI->enablePropertyUI( PROPERTY_EMPTY_IS_NULL, !xBinding.is() );
 149
 150             aDependentProperties.push_back( PROPERTY_ID_BOUNDCOLUMN );
 151
 152             if ( !xBinding.is() && m_pHelper->getCurrentBinding().is() )
 153             {
 154                 // ensure that the "transfer selection as" property is reset. Since we can't remember
 155                 // it at the object itself, but derive it from the binding only, we have to normalize
 156                 // it now that there *is* no binding anymore.
 157                 setPropertyValue( PROPERTY_CELL_EXCHANGE_TYPE, makeAny( (sal_Int16) 0 ) );
 158             }
 159         }
 160         break;
 161
 162         // ----- CellRange -----
 163         case PROPERTY_ID_LIST_CELL_RANGE:
 164         {
 165             // the list source related properties need to be enabled if and only if
 166             // there is *no* valid external list source for the control
 167             Reference< XListEntrySource > xSource;
 168             _rNewValue >>= xSource;
 169
 170             _rxInspectorUI->enablePropertyUI( PROPERTY_STRINGITEMLIST, !xSource.is() );
 171             _rxInspectorUI->enablePropertyUI( PROPERTY_LISTSOURCE, !xSource.is() );
 172             _rxInspectorUI->enablePropertyUI( PROPERTY_LISTSOURCETYPE, !xSource.is() );
 173
 174             aDependentProperties.push_back( PROPERTY_ID_BOUNDCOLUMN );
 175
 176             // also reset the list entries if the cell range is reset
 177             // #i28319# - 2004-04-27 - fs@openoffice.org
 178             if ( !_bFirstTimeInit )
 179             {
 180                 try
 181                 {
 182                     if ( !xSource.is() )
 183                         setPropertyValue( PROPERTY_STRINGITEMLIST, makeAny( Sequence< ::rtl::OUString >() ) );
 184                 }
 185                 catch( const Exception& )
 186                 {
 187                     OSL_ENSURE( sal_False, "OPropertyBrowserController::actuatingPropertyChanged( ListCellRange ): caught an exception while resetting the string items!" );
 188                 }
 189             }
 190         }
 191         break;  // case PROPERTY_ID_LIST_CELL_RANGE
 192
 193         // ----- DataField -----
 194         case PROPERTY_ID_CONTROLSOURCE:
 195         {
 196             ::rtl::OUString sControlSource;
 197             _rNewValue >>= sControlSource;
 198             if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_BOUND_CELL ) )
 199                 _rxInspectorUI->enablePropertyUI( PROPERTY_BOUND_CELL, sControlSource.getLength() == 0 );
 200         }
 201         break;  // case PROPERTY_ID_CONTROLSOURCE
 202
 203         default:
 204             DBG_ERROR( "CellBindingPropertyHandler::actuatingPropertyChanged: did not register for this property!" );
 205         }
 206
 207         for ( ::std::vector< PropertyId >::const_iterator loopAffected = aDependentProperties.begin();
 208               loopAffected != aDependentProperties.end();
 209               ++loopAffected
 210             )
 211         {
 212             impl_updateDependentProperty_nothrow( *loopAffected, _rxInspectorUI );
 213         }
 214     }
 215
 216     //--------------------------------------------------------------------
 217     void CellBindingPropertyHandler::impl_updateDependentProperty_nothrow( PropertyId _nPropId, const Reference< XObjectInspectorUI >& _rxInspectorUI ) const
 218     {
 219         try
 220         {
 221             switch ( _nPropId )
 222             {
 223             // ----- BoundColumn -----
 224             case PROPERTY_ID_BOUNDCOLUMN:
 225             {
 226                 CellBindingPropertyHandler* pNonConstThis = const_cast< CellBindingPropertyHandler* >( this );
 227                 Reference< XValueBinding > xBinding( pNonConstThis->getPropertyValue( PROPERTY_BOUND_CELL ), UNO_QUERY );
 228                 Reference< XListEntrySource > xListSource( pNonConstThis->getPropertyValue( PROPERTY_LIST_CELL_RANGE ), UNO_QUERY );
 229
 230                 if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_BOUNDCOLUMN ) )
 231                     _rxInspectorUI->enablePropertyUI( PROPERTY_BOUNDCOLUMN, !xBinding.is() && !xListSource.is() );
 232             }
 233             break;  // case PROPERTY_ID_BOUNDCOLUMN
 234
 235             }   // switch
 236
 237         }
 238         catch( const Exception& )
 239         {
 240             OSL_ENSURE( sal_False, "CellBindingPropertyHandler::impl_updateDependentProperty_nothrow: caught an exception!" );
 241         }
 242     }
 243
 244     //--------------------------------------------------------------------
 245     Any SAL_CALL CellBindingPropertyHandler::getPropertyValue( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException)
 246     {
 247         ::osl::MutexGuard aGuard( m_aMutex );
 248         PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) );
 249
 250         OSL_ENSURE( m_pHelper.get(), "CellBindingPropertyHandler::getPropertyValue: inconsistency!" );
 251             // if we survived impl_getPropertyId_throw, we should have a helper, since no helper implies no properties
 252
 253         Any aReturn;
 254         switch ( nPropId )
 255         {
 256         case PROPERTY_ID_BOUND_CELL:
 257         {
 258             Reference< XValueBinding > xBinding( m_pHelper->getCurrentBinding() );
 259             if ( !m_pHelper->isCellBinding( xBinding ) )
 260                 xBinding.clear();
 261
 262             aReturn <<= xBinding;
 263         }
 264         break;
 265
 266         case PROPERTY_ID_LIST_CELL_RANGE:
 267         {
 268             Reference< XListEntrySource > xSource( m_pHelper->getCurrentListSource() );
 269             if ( !m_pHelper->isCellRangeListSource( xSource ) )
 270                 xSource.clear();
 271
 272             aReturn <<= xSource;
 273         }
 274         break;
 275
 276         case PROPERTY_ID_CELL_EXCHANGE_TYPE:
 277         {
 278             Reference< XValueBinding > xBinding( m_pHelper->getCurrentBinding() );
 279             aReturn <<= (sal_Int16)( m_pHelper->isCellIntegerBinding( xBinding ) ? 1 : 0 );
 280         }
 281         break;
 282
 283         default:
 284             DBG_ERROR( "CellBindingPropertyHandler::getPropertyValue: cannot handle this!" );
 285             break;
 286         }
 287         return aReturn;
 288     }
 289
 290     //--------------------------------------------------------------------
 291     void SAL_CALL CellBindingPropertyHandler::setPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rValue ) throw (UnknownPropertyException, RuntimeException)
 292     {
 293         ::osl::MutexGuard aGuard( m_aMutex );
 294         PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) );
 295
 296         OSL_ENSURE( m_pHelper.get(), "CellBindingPropertyHandler::setPropertyValue: inconsistency!" );
 297             // if we survived impl_getPropertyId_throw, we should have a helper, since no helper implies no properties
 298
 299         try
 300         {
 301             Any aOldValue = getPropertyValue( _rPropertyName );
 302
 303             switch ( nPropId )
 304             {
 305             case PROPERTY_ID_BOUND_CELL:
 306             {
 307                 Reference< XValueBinding > xBinding;
 308                 _rValue >>= xBinding;
 309                 m_pHelper->setBinding( xBinding );
 310             }
 311             break;
 312
 313             case PROPERTY_ID_LIST_CELL_RANGE:
 314             {
 315                 Reference< XListEntrySource > xSource;
 316                 _rValue >>= xSource;
 317                 m_pHelper->setListSource( xSource );
 318             }
 319             break;
 320
 321             case PROPERTY_ID_CELL_EXCHANGE_TYPE:
 322             {
 323                 sal_Int16 nExchangeType = 0;
 324                 OSL_VERIFY( _rValue >>= nExchangeType );
 325
 326                 Reference< XValueBinding > xBinding = m_pHelper->getCurrentBinding( );
 327                 if ( xBinding.is() )
 328                 {
 329                     sal_Bool bNeedIntegerBinding = ( nExchangeType == 1 );
 330                     if ( (bool)bNeedIntegerBinding != m_pHelper->isCellIntegerBinding( xBinding ) )
 331                     {
 332                         CellAddress aAddress;
 333                         if ( m_pHelper->getAddressFromCellBinding( xBinding, aAddress ) )
 334                         {
 335                             xBinding = m_pHelper->createCellBindingFromAddress( aAddress, bNeedIntegerBinding );
 336                             m_pHelper->setBinding( xBinding );
 337                         }
 338                     }
 339                 }
 340             }
 341             break;
 342
 343             default:
 344                 DBG_ERROR( "CellBindingPropertyHandler::setPropertyValue: cannot handle this!" );
 345                 break;
 346             }
 347
 348             impl_setContextDocumentModified_nothrow();
 349
 350             Any aNewValue( getPropertyValue( _rPropertyName ) );
 351             firePropertyChange( _rPropertyName, nPropId, aOldValue, aNewValue );
 352             // TODO/UNOize: can't we make this a part of the base class, for all those "virtual"
 353             // properties? Base class'es |setPropertyValue| could call some |doSetPropertyValue|,
 354             // and handle the listener notification itself
 355         }
 356         catch( const Exception& )
 357         {
 358             OSL_ENSURE( sal_False, "CellBindingPropertyHandler::setPropertyValue: caught an exception!" );
 359         }
 360     }
 361
 362     //--------------------------------------------------------------------
 363     Any SAL_CALL CellBindingPropertyHandler::convertToPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rControlValue ) throw (UnknownPropertyException, RuntimeException)
 364     {
 365         ::osl::MutexGuard aGuard( m_aMutex );
 366         Any aPropertyValue;
 367
 368         OSL_ENSURE( m_pHelper.get(), "CellBindingPropertyHandler::convertToPropertyValue: we have no SupportedProperties!" );
 369         if ( !m_pHelper.get() )
 370             return aPropertyValue;
 371
 372         PropertyId nPropId( m_pInfoService->getPropertyId( _rPropertyName ) );
 373
 374         ::rtl::OUString sControlValue;
 375         OSL_VERIFY( _rControlValue >>= sControlValue );
 376         switch( nPropId )
 377         {
 378             case PROPERTY_ID_LIST_CELL_RANGE:
 379                 aPropertyValue <<= m_pHelper->createCellListSourceFromStringAddress( sControlValue );
 380                 break;
 381
 382             case PROPERTY_ID_BOUND_CELL:
 383             {
 384                 // if we have the possibility of an integer binding, then we must preserve
 385                 // this property's value (e.g. if the current binding is an integer binding, then
 386                 // the newly created one must be, too)
 387                 bool bIntegerBinding = false;
 388                 if ( m_pHelper->isCellIntegerBindingAllowed() )
 389                 {
 390                     sal_Int16 nCurrentBindingType = 0;
 391                     getPropertyValue( PROPERTY_CELL_EXCHANGE_TYPE ) >>= nCurrentBindingType;
 392                     bIntegerBinding = ( nCurrentBindingType != 0 );
 393                 }
 394                 aPropertyValue <<= m_pHelper->createCellBindingFromStringAddress( sControlValue, bIntegerBinding );
 395             }
 396             break;
 397
 398             case PROPERTY_ID_CELL_EXCHANGE_TYPE:
 399                 m_pCellExchangeConverter->getValueFromDescription( sControlValue, aPropertyValue );
 400                 break;
 401
 402             default:
 403                 DBG_ERROR( "CellBindingPropertyHandler::convertToPropertyValue: cannot handle this!" );
 404                 break;
 405         }
 406
 407         return aPropertyValue;
 408     }
 409
 410     //--------------------------------------------------------------------
 411     Any SAL_CALL CellBindingPropertyHandler::convertToControlValue( const ::rtl::OUString& _rPropertyName,
 412         const Any& _rPropertyValue, const Type& /*_rControlValueType*/ ) throw (UnknownPropertyException, RuntimeException)
 413     {
 414         ::osl::MutexGuard aGuard( m_aMutex );
 415         Any aControlValue;
 416
 417         OSL_ENSURE( m_pHelper.get(), "CellBindingPropertyHandler::convertToControlValue: we have no SupportedProperties!" );
 418         if ( !m_pHelper.get() )
 419             return aControlValue;
 420
 421         PropertyId nPropId( m_pInfoService->getPropertyId( _rPropertyName ) );
 422
 423         switch ( nPropId )
 424         {
 425             case PROPERTY_ID_BOUND_CELL:
 426             {
 427                 Reference< XValueBinding > xBinding;
 428 #if OSL_DEBUG_LEVEL > 0
 429                 sal_Bool bSuccess =
 430 #endif
 431                 _rPropertyValue >>= xBinding;
 432                 OSL_ENSURE( bSuccess, "CellBindingPropertyHandler::convertToControlValue: invalid value (1)!" );
 433
 434                 // the only value binding we support so far is linking to spreadsheet cells
 435                 aControlValue <<= m_pHelper->getStringAddressFromCellBinding( xBinding );
 436             }
 437             break;
 438
 439             case PROPERTY_ID_LIST_CELL_RANGE:
 440             {
 441                 Reference< XListEntrySource > xSource;
 442 #if OSL_DEBUG_LEVEL > 0
 443                 sal_Bool bSuccess =
 444 #endif
 445                 _rPropertyValue >>= xSource;
 446                 OSL_ENSURE( bSuccess, "CellBindingPropertyHandler::convertToControlValue: invalid value (2)!" );
 447
 448                 // the only value binding we support so far is linking to spreadsheet cells
 449                 aControlValue <<= m_pHelper->getStringAddressFromCellListSource( xSource );
 450             }
 451             break;
 452
 453             case PROPERTY_ID_CELL_EXCHANGE_TYPE:
 454                 aControlValue <<= m_pCellExchangeConverter->getDescriptionForValue( _rPropertyValue );
 455                 break;
 456
 457             default:
 458                 DBG_ERROR( "CellBindingPropertyHandler::convertToControlValue: cannot handle this!" );
 459                 break;
 460         }
 461
 462         return aControlValue;
 463     }
 464
 465     //--------------------------------------------------------------------
 466     Sequence< Property > SAL_CALL CellBindingPropertyHandler::doDescribeSupportedProperties() const
 467     {
 468         ::std::vector< Property > aProperties;
 469
 470         bool bAllowCellLinking      = m_pHelper.get() && m_pHelper->isCellBindingAllowed();
 471         bool bAllowCellIntLinking   = m_pHelper.get() && m_pHelper->isCellIntegerBindingAllowed();
 472         bool bAllowListCellRange    = m_pHelper.get() && m_pHelper->isListCellRangeAllowed();
 473         if ( bAllowCellLinking || bAllowListCellRange || bAllowCellIntLinking )
 474         {
 475             sal_Int32 nPos =  ( bAllowCellLinking    ? 1 : 0 )
 476                             + ( bAllowListCellRange  ? 1 : 0 )
 477                             + ( bAllowCellIntLinking ? 1 : 0 );
 478             aProperties.resize( nPos );
 479
 480             if ( bAllowCellLinking )
 481             {
 482                 aProperties[ --nPos ] = Property( PROPERTY_BOUND_CELL, PROPERTY_ID_BOUND_CELL,
 483                     ::getCppuType( static_cast< ::rtl::OUString* >( NULL ) ), 0 );
 484             }
 485             if ( bAllowCellIntLinking )
 486             {
 487                 aProperties[ --nPos ] = Property( PROPERTY_CELL_EXCHANGE_TYPE, PROPERTY_ID_CELL_EXCHANGE_TYPE,
 488                     ::getCppuType( static_cast< sal_Int16* >( NULL ) ), 0 );
 489             }
 490             if ( bAllowListCellRange )
 491             {
 492                 aProperties[ --nPos ] = Property( PROPERTY_LIST_CELL_RANGE, PROPERTY_ID_LIST_CELL_RANGE,
 493                     ::getCppuType( static_cast< ::rtl::OUString* >( NULL ) ), 0 );
 494             }
 495         }
 496
 497         if ( aProperties.empty() )
 498             return Sequence< Property >();
 499         return Sequence< Property >( &(*aProperties.begin()), aProperties.size() );
 500     }
 501
 502 //........................................................................
 503 }   // namespace pcr
 504 //........................................................................