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