extensions/source/propctrlr/cellbindinghelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cellbindinghelper.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33 #include "cellbindinghelper.hxx"
  34 #include <com/sun/star/form/binding/XBindableValue.hpp>
  35 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  36 #include <com/sun/star/form/FormComponentType.hpp>
  37 #include <com/sun/star/form/XGridColumnFactory.hpp>
  38 #include <com/sun/star/container/XChild.hpp>
  39 #include <com/sun/star/container/XNamed.hpp>
  40 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
  41 #include <com/sun/star/table/XCellRange.hpp>
  42 #include <com/sun/star/form/XFormsSupplier.hpp>
  43 #include <com/sun/star/form/XForm.hpp>
  44 #include <com/sun/star/lang/XServiceInfo.hpp>
  45 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  46 #include <com/sun/star/beans/NamedValue.hpp>
  47 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  48 #include <unotools/transliterationwrapper.hxx>
  49 #include <osl/diagnose.h>
  50 #include <tools/diagnose_ex.h>
  51 #include "formstrings.hxx"
  52
  53 #include <functional>
  54 #include <algorithm>
  55
  56 //............................................................................
  57 namespace pcr
  58 {
  59 //............................................................................
  60
  61     using namespace ::com::sun::star::uno;
  62     using namespace ::com::sun::star::beans;
  63     using namespace ::com::sun::star::frame;
  64     using namespace ::com::sun::star::sheet;
  65     using namespace ::com::sun::star::container;
  66     using namespace ::com::sun::star::drawing;
  67     using namespace ::com::sun::star::table;
  68     using namespace ::com::sun::star::form;
  69     using namespace ::com::sun::star::lang;
  70     using namespace ::com::sun::star::i18n;
  71     using namespace ::com::sun::star::form::binding;
  72
  73     namespace
  74     {
  75         //....................................................................
  76         struct StringCompare : public ::std::unary_function< ::rtl::OUString, bool >
  77         {
  78         private:
  79             ::rtl::OUString m_sReference;
  80
  81         public:
  82             StringCompare( const ::rtl::OUString& _rReference ) : m_sReference( _rReference ) { }
  83
  84             inline bool operator()( const ::rtl::OUString& _rCompare )
  85             {
  86                 return ( _rCompare == m_sReference ) ? true : false;
  87             }
  88         };
  89     }
  90
  91     //========================================================================
  92     //= CellBindingHelper
  93     //========================================================================
  94     //------------------------------------------------------------------------
  95     CellBindingHelper::CellBindingHelper( const Reference< XPropertySet >& _rxControlModel, const Reference< XModel >& _rxContextDocument )
  96         :m_xControlModel( _rxControlModel )
  97     {
  98         OSL_ENSURE( m_xControlModel.is(), "CellBindingHelper::CellBindingHelper: invalid control model!" );
  99
 100         m_xDocument = m_xDocument.query( _rxContextDocument );
 101         OSL_ENSURE( m_xDocument.is(), "CellBindingHelper::CellBindingHelper: This is no spreadsheet document!" );
 102
 103         OSL_ENSURE( isSpreadsheetDocumentWhichSupplies( SERVICE_ADDRESS_CONVERSION ),
 104             "CellBindingHelper::CellBindingHelper: the document cannot convert address representations!" );
 105     }
 106
 107     //------------------------------------------------------------------------
 108     sal_Bool CellBindingHelper::isSpreadsheetDocument( const Reference< XModel >& _rxContextDocument )
 109     {
 110         return Reference< XSpreadsheetDocument >::query( _rxContextDocument ).is();
 111     }
 112
 113     //------------------------------------------------------------------------
 114     sal_Int16 CellBindingHelper::getControlSheetIndex( Reference< XSpreadsheet >& _out_rxSheet ) const
 115     {
 116         sal_Int16 nSheetIndex = -1;
 117         // every sheet has a draw page, and every draw page has a forms collection.
 118         // Our control, OTOH, belongs to a forms collection. Match these ...
 119         try
 120         {
 121             // for determining the draw page, we need the forms collection which
 122             // the object belongs to. This is the first object up the hierarchy which is
 123             // *no* XForm (and, well, no XGridColumnFactory)
 124             Reference< XChild > xCheck( m_xControlModel, UNO_QUERY );
 125             Reference< XForm > xParentAsForm; if ( xCheck.is() ) xParentAsForm = xParentAsForm.query( xCheck->getParent() );
 126             Reference< XGridColumnFactory > xParentAsGrid; if ( xCheck.is() ) xParentAsGrid = xParentAsGrid.query( xCheck->getParent() );
 127
 128             while ( ( xParentAsForm.is() || xParentAsGrid.is() ) && xCheck.is() )
 129             {
 130                 xCheck = xCheck.query( xCheck->getParent() );
 131                 xParentAsForm = xParentAsForm.query( xCheck.is() ? xCheck->getParent() : (Reference< XInterface >) Reference< XForm >() );
 132                 xParentAsGrid = xParentAsGrid.query( xCheck.is() ? xCheck->getParent() : (Reference< XInterface >) Reference< XGridColumnFactory >() );
 133             }
 134             Reference< XInterface > xFormsCollection( xCheck.is() ? xCheck->getParent() : Reference< XInterface >() );
 135
 136             // now iterate through the sheets
 137             Reference< XIndexAccess > xSheets( m_xDocument->getSheets(), UNO_QUERY );
 138             if ( xSheets.is() && xFormsCollection.is() )
 139             {
 140                 for ( sal_Int32 i = 0; i < xSheets->getCount(); ++i )
 141                 {
 142                     Reference< XDrawPageSupplier > xSuppPage( xSheets->getByIndex( i ), UNO_QUERY_THROW );
 143                     Reference< XFormsSupplier > xSuppForms( xSuppPage->getDrawPage(), UNO_QUERY_THROW );
 144
 145                     if ( xSuppForms->getForms() == xFormsCollection )
 146                     {   // found it
 147                         nSheetIndex = (sal_Int16)i;
 148                         _out_rxSheet.set( xSuppPage, UNO_QUERY_THROW );
 149                         break;
 150                     }
 151                 }
 152             }
 153         }
 154         catch( const Exception& )
 155         {
 156             DBG_UNHANDLED_EXCEPTION();
 157         }
 158
 159         return nSheetIndex;
 160     }
 161
 162     //------------------------------------------------------------------------
 163     bool CellBindingHelper::convertStringAddress( const ::rtl::OUString& _rAddressDescription, CellAddress& /* [out] */ _rAddress ) const
 164     {
 165         Any aAddress;
 166         return doConvertAddressRepresentations(
 167                     PROPERTY_UI_REPRESENTATION,
 168                     makeAny( _rAddressDescription ),
 169                     PROPERTY_ADDRESS,
 170                     aAddress,
 171                     false
 172                )
 173            &&  ( aAddress >>= _rAddress );
 174     }
 175
 176     //------------------------------------------------------------------------
 177     bool CellBindingHelper::doConvertAddressRepresentations( const ::rtl::OUString& _rInputProperty, const Any& _rInputValue,
 178         const ::rtl::OUString& _rOutputProperty, Any& _rOutputValue, bool _bIsRange ) const SAL_THROW(())
 179     {
 180         bool bSuccess = false;
 181
 182         Reference< XPropertySet > xConverter(
 183             createDocumentDependentInstance(
 184                 _bIsRange ? SERVICE_RANGEADDRESS_CONVERSION : SERVICE_ADDRESS_CONVERSION,
 185                 ::rtl::OUString(),
 186                 Any()
 187             ),
 188             UNO_QUERY
 189         );
 190         OSL_ENSURE( xConverter.is(), "CellBindingHelper::doConvertAddressRepresentations: could not get a converter service!" );
 191         if ( xConverter.is() )
 192         {
 193             try
 194             {
 195                 Reference< XSpreadsheet > xSheet;
 196                 xConverter->setPropertyValue( PROPERTY_REFERENCE_SHEET, makeAny( (sal_Int32)getControlSheetIndex( xSheet ) ) );
 197                 xConverter->setPropertyValue( _rInputProperty, _rInputValue );
 198                 _rOutputValue = xConverter->getPropertyValue( _rOutputProperty );
 199                 bSuccess = true;
 200             }
 201             catch( const Exception& )
 202             {
 203                 OSL_ENSURE( sal_False, "CellBindingHelper::doConvertAddressRepresentations: caught an exception!" );
 204             }
 205         }
 206
 207         return bSuccess;
 208     }
 209
 210     //------------------------------------------------------------------------
 211     bool CellBindingHelper::convertStringAddress( const ::rtl::OUString& _rAddressDescription,
 212                             CellRangeAddress& /* [out] */ _rAddress ) const
 213     {
 214         Any aAddress;
 215         return doConvertAddressRepresentations(
 216                     PROPERTY_UI_REPRESENTATION,
 217                     makeAny( _rAddressDescription ),
 218                     PROPERTY_ADDRESS,
 219                     aAddress,
 220                     true
 221                )
 222            &&  ( aAddress >>= _rAddress );
 223     }
 224
 225     //------------------------------------------------------------------------
 226     Reference< XValueBinding > CellBindingHelper::createCellBindingFromAddress( const CellAddress& _rAddress, bool _bSupportIntegerExchange ) const
 227     {
 228         Reference< XValueBinding > xBinding( createDocumentDependentInstance(
 229             _bSupportIntegerExchange ? SERVICE_SHEET_CELL_INT_BINDING : SERVICE_SHEET_CELL_BINDING,
 230             PROPERTY_BOUND_CELL,
 231             makeAny( _rAddress )
 232         ), UNO_QUERY );
 233
 234         return xBinding;
 235     }
 236
 237     //------------------------------------------------------------------------
 238     Reference< XValueBinding > CellBindingHelper::createCellBindingFromStringAddress( const ::rtl::OUString& _rAddress, bool _bSupportIntegerExchange ) const
 239     {
 240         Reference< XValueBinding > xBinding;
 241         if ( !m_xDocument.is() )
 242             // very bad ...
 243             return xBinding;
 244
 245         // get the UNO representation of the address
 246         CellAddress aAddress;
 247         if ( !_rAddress.getLength() || !convertStringAddress( _rAddress, aAddress ) )
 248             return xBinding;
 249
 250         return createCellBindingFromAddress( aAddress, _bSupportIntegerExchange );
 251     }
 252
 253     //------------------------------------------------------------------------
 254     Reference< XListEntrySource > CellBindingHelper::createCellListSourceFromStringAddress( const ::rtl::OUString& _rAddress ) const
 255     {
 256         Reference< XListEntrySource > xSource;
 257
 258         CellRangeAddress aRangeAddress;
 259         if ( !_rAddress.getLength() || !convertStringAddress( _rAddress, aRangeAddress ) )
 260             return xSource;
 261
 262         // create a range object for this address
 263         xSource = xSource.query( createDocumentDependentInstance(
 264             SERVICE_SHEET_CELLRANGE_LISTSOURCE,
 265             PROPERTY_LIST_CELL_RANGE,
 266             makeAny( aRangeAddress )
 267         ) );
 268
 269         return xSource;
 270     }
 271
 272     //------------------------------------------------------------------------
 273     Reference< XInterface > CellBindingHelper::createDocumentDependentInstance( const ::rtl::OUString& _rService, const ::rtl::OUString& _rArgumentName,
 274         const Any& _rArgumentValue ) const
 275     {
 276         Reference< XInterface > xReturn;
 277
 278         Reference< XMultiServiceFactory > xDocumentFactory( m_xDocument, UNO_QUERY );
 279         OSL_ENSURE( xDocumentFactory.is(), "CellBindingHelper::createDocumentDependentInstance: no document service factory!" );
 280         if ( xDocumentFactory.is() )
 281         {
 282             try
 283             {
 284                 if ( _rArgumentName.getLength() )
 285                 {
 286                     NamedValue aArg;
 287                     aArg.Name = _rArgumentName;
 288                     aArg.Value = _rArgumentValue;
 289
 290                     Sequence< Any > aArgs( 1 );
 291                     aArgs[ 0 ] <<= aArg;
 292
 293                     xReturn = xDocumentFactory->createInstanceWithArguments( _rService, aArgs );
 294                 }
 295                 else
 296                 {
 297                     xReturn = xDocumentFactory->createInstance( _rService );
 298                 }
 299             }
 300             catch ( const Exception& )
 301             {
 302                 OSL_ENSURE( sal_False, "CellBindingHelper::createDocumentDependentInstance: could not create the binding at the document!" );
 303             }
 304         }
 305         return xReturn;
 306     }
 307
 308     //------------------------------------------------------------------------
 309     bool CellBindingHelper::getAddressFromCellBinding(
 310         const Reference< XValueBinding >& _rxBinding, CellAddress& _rAddress ) const
 311     {
 312         OSL_PRECOND( !_rxBinding.is() || isCellBinding( _rxBinding ), "CellBindingHelper::getAddressFromCellBinding: this is no cell binding!" );
 313
 314         bool bReturn = false;
 315         if ( !m_xDocument.is() )
 316             // very bad ...
 317             return bReturn;
 318
 319         try
 320         {
 321             Reference< XPropertySet > xBindingProps( _rxBinding, UNO_QUERY );
 322             OSL_ENSURE( xBindingProps.is() || !_rxBinding.is(), "CellBindingHelper::getAddressFromCellBinding: no property set for the binding!" );
 323             if ( xBindingProps.is() )
 324             {
 325                 CellAddress aAddress;
 326                 bReturn = (bool)( xBindingProps->getPropertyValue( PROPERTY_BOUND_CELL ) >>= _rAddress );
 327             }
 328         }
 329         catch( const Exception& )
 330         {
 331             OSL_ENSURE( sal_False, "CellBindingHelper::getAddressFromCellBinding: caught an exception!" );
 332         }
 333
 334         return bReturn;
 335     }
 336
 337     //------------------------------------------------------------------------
 338     ::rtl::OUString CellBindingHelper::getStringAddressFromCellBinding( const Reference< XValueBinding >& _rxBinding ) const
 339     {
 340         CellAddress aAddress;
 341         ::rtl::OUString sAddress;
 342         if ( getAddressFromCellBinding( _rxBinding, aAddress ) )
 343         {
 344             Any aStringAddress;
 345             doConvertAddressRepresentations( PROPERTY_ADDRESS, makeAny( aAddress ),
 346                 PROPERTY_UI_REPRESENTATION, aStringAddress, false );
 347
 348             aStringAddress >>= sAddress;
 349         }
 350
 351         return sAddress;
 352     }
 353
 354     //------------------------------------------------------------------------
 355     ::rtl::OUString CellBindingHelper::getStringAddressFromCellListSource( const Reference< XListEntrySource >& _rxSource ) const
 356     {
 357         OSL_PRECOND( !_rxSource.is() || isCellRangeListSource( _rxSource ), "CellBindingHelper::getStringAddressFromCellListSource: this is no cell list source!" );
 358
 359         ::rtl::OUString sAddress;
 360         if ( !m_xDocument.is() )
 361             // very bad ...
 362             return sAddress;
 363
 364         try
 365         {
 366             Reference< XPropertySet > xSourceProps( _rxSource, UNO_QUERY );
 367             OSL_ENSURE( xSourceProps.is() || !_rxSource.is(), "CellBindingHelper::getStringAddressFromCellListSource: no property set for the list source!" );
 368             if ( xSourceProps.is() )
 369             {
 370                 CellRangeAddress aRangeAddress;
 371                 xSourceProps->getPropertyValue( PROPERTY_LIST_CELL_RANGE ) >>= aRangeAddress;
 372
 373                 Any aStringAddress;
 374                 doConvertAddressRepresentations( PROPERTY_ADDRESS, makeAny( aRangeAddress ),
 375                     PROPERTY_UI_REPRESENTATION, aStringAddress, true );
 376                 aStringAddress >>= sAddress;
 377             }
 378         }
 379         catch( const Exception& )
 380         {
 381             OSL_ENSURE( sal_False, "CellBindingHelper::getStringAddressFromCellListSource: caught an exception!" );
 382         }
 383
 384         return sAddress;
 385     }
 386
 387     //------------------------------------------------------------------------
 388     bool CellBindingHelper::isSpreadsheetDocumentWhichSupplies( const ::rtl::OUString& _rService ) const
 389     {
 390         bool bYesItIs = false;
 391
 392         Reference< XServiceInfo > xSI( m_xDocument, UNO_QUERY );
 393         if ( xSI.is() && xSI->supportsService( SERVICE_SPREADSHEET_DOCUMENT ) )
 394         {
 395             Reference< XMultiServiceFactory > xDocumentFactory( m_xDocument, UNO_QUERY );
 396             OSL_ENSURE( xDocumentFactory.is(), "CellBindingHelper::isSpreadsheetDocumentWhichSupplies: spreadsheet document, but no factory?" );
 397
 398             Sequence< ::rtl::OUString > aAvailableServices;
 399             if ( xDocumentFactory.is() )
 400                 aAvailableServices = xDocumentFactory->getAvailableServiceNames( );
 401
 402             const ::rtl::OUString* pFound = ::std::find_if(
 403                 aAvailableServices.getConstArray(),
 404                 aAvailableServices.getConstArray() + aAvailableServices.getLength(),
 405                 StringCompare( _rService )
 406             );
 407             if ( pFound - aAvailableServices.getConstArray() < aAvailableServices.getLength() )
 408             {
 409                 bYesItIs = true;
 410             }
 411         }
 412
 413         return bYesItIs;
 414     }
 415
 416     //------------------------------------------------------------------------
 417     bool CellBindingHelper::isListCellRangeAllowed( ) const
 418     {
 419         bool bAllow( false );
 420
 421         Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 422         if ( xSink.is() )
 423         {
 424             bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_SHEET_CELLRANGE_LISTSOURCE );
 425         }
 426
 427         return bAllow;
 428     }
 429
 430     //------------------------------------------------------------------------
 431     bool CellBindingHelper::isCellIntegerBindingAllowed( ) const
 432     {
 433         bool bAllow( true );
 434
 435         // first, we only offer this for controls which allow bindings in general
 436         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 437         if ( !xBindable.is() )
 438             bAllow = false;
 439
 440         // then, we must live in a spreadsheet document which can provide the special
 441         // service needed for exchanging integer values
 442         if ( bAllow )
 443             bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_SHEET_CELL_INT_BINDING );
 444
 445         // then, we only offer this for list boxes
 446         if ( bAllow )
 447         {
 448             try
 449             {
 450                 sal_Int16 nClassId = FormComponentType::CONTROL;
 451                 m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nClassId;
 452                 if ( FormComponentType::LISTBOX != nClassId )
 453                     bAllow = false;
 454             }
 455             catch( const Exception& )
 456             {
 457                 OSL_ENSURE( sal_False, "CellBindingHelper::isCellIntegerBindingAllowed: caught an exception!" );
 458                     // are there really control models which survive isCellBindingAllowed, but don't have a ClassId
 459                     // property?
 460                 bAllow = false;
 461             }
 462         }
 463
 464         return bAllow;
 465     }
 466
 467     //------------------------------------------------------------------------
 468     bool CellBindingHelper::isCellBindingAllowed( ) const
 469     {
 470         bool bAllow( false );
 471
 472         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 473         if ( xBindable.is() )
 474         {
 475             // the control can potentially be bound to an external value
 476             // Does it live within a Calc document, and is able to supply CellBindings?
 477             bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_SHEET_CELL_BINDING );
 478         }
 479
 480         // disallow for some types
 481         // TODO: shouldn't the XBindableValue supply a list of supported types, and we can distingusih
 482         // using this list? The current behavior below is somewhat hackish ...
 483         if ( bAllow )
 484         {
 485             try
 486             {
 487                 sal_Int16 nClassId = FormComponentType::CONTROL;
 488                 m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nClassId;
 489                 if ( ( FormComponentType::DATEFIELD == nClassId ) || ( FormComponentType::TIMEFIELD == nClassId ) )
 490                     bAllow = false;
 491             }
 492             catch( const Exception& )
 493             {
 494                 OSL_ENSURE( sal_False, "CellBindingHelper::isCellBindingAllowed: caught an exception!" );
 495                 bAllow = false;
 496             }
 497         }
 498         return bAllow;
 499     }
 500
 501     //------------------------------------------------------------------------
 502     bool CellBindingHelper::isCellBinding( const Reference< XValueBinding >& _rxBinding ) const
 503     {
 504         return doesComponentSupport( _rxBinding.get(), SERVICE_SHEET_CELL_BINDING );
 505     }
 506
 507     //------------------------------------------------------------------------
 508     bool CellBindingHelper::isCellIntegerBinding( const Reference< XValueBinding >& _rxBinding ) const
 509     {
 510         return doesComponentSupport( _rxBinding.get(), SERVICE_SHEET_CELL_INT_BINDING );
 511     }
 512
 513     //------------------------------------------------------------------------
 514     bool CellBindingHelper::isCellRangeListSource( const Reference< XListEntrySource >& _rxSource ) const
 515     {
 516         return doesComponentSupport( _rxSource.get(), SERVICE_SHEET_CELLRANGE_LISTSOURCE );
 517     }
 518
 519     //------------------------------------------------------------------------
 520     bool CellBindingHelper::doesComponentSupport( const Reference< XInterface >& _rxComponent, const ::rtl::OUString& _rService ) const
 521     {
 522         bool bDoes = false;
 523         Reference< XServiceInfo > xSI( _rxComponent, UNO_QUERY );
 524         bDoes = xSI.is() && xSI->supportsService( _rService );
 525         return bDoes;
 526     }
 527
 528     //------------------------------------------------------------------------
 529     Reference< XValueBinding > CellBindingHelper::getCurrentBinding( ) const
 530     {
 531         Reference< XValueBinding > xBinding;
 532         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 533         if ( xBindable.is() )
 534             xBinding = xBindable->getValueBinding();
 535         return xBinding;
 536     }
 537
 538     //------------------------------------------------------------------------
 539     Reference< XListEntrySource > CellBindingHelper::getCurrentListSource( ) const
 540     {
 541         Reference< XListEntrySource > xSource;
 542         Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 543         if ( xSink.is() )
 544             xSource = xSink->getListEntrySource();
 545         return xSource;
 546     }
 547
 548     //------------------------------------------------------------------------
 549     void CellBindingHelper::setBinding( const Reference< XValueBinding >& _rxBinding )
 550     {
 551         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 552         OSL_PRECOND( xBindable.is(), "CellBindingHelper::setBinding: the object is not bindable!" );
 553         if ( xBindable.is() )
 554             xBindable->setValueBinding( _rxBinding );
 555     }
 556
 557     //------------------------------------------------------------------------
 558     void CellBindingHelper::setListSource( const Reference< XListEntrySource >& _rxSource )
 559     {
 560         Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 561         OSL_PRECOND( xSink.is(), "CellBindingHelper::setListSource: the object is no list entry sink!" );
 562         if ( xSink.is() )
 563             xSink->setListEntrySource( _rxSource );
 564     }
 565
 566 //............................................................................
 567 }   // namespace pcr
 568 //............................................................................