| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_sc.hxx" | |
| #include "cellvaluebinding.hxx" | |
| #include <tools/debug.hxx> | |
| #include <rtl/math.hxx> | |
| #include <com/sun/star/table/XCellRange.hpp> | |
| #include <com/sun/star/sheet/XCellAddressable.hpp> | |
| #include <com/sun/star/sheet/XCellRangeData.hpp> | |
| #include <com/sun/star/container/XIndexAccess.hpp> | |
| #include <com/sun/star/beans/PropertyAttribute.hpp> | |
| #include <com/sun/star/beans/NamedValue.hpp> | |
| #include <com/sun/star/util/XNumberFormatsSupplier.hpp> | |
| #include <com/sun/star/util/XNumberFormatTypes.hpp> | |
| #include <com/sun/star/util/NumberFormat.hpp> | |
| //......................................................................... | |
| namespace calc | |
| { | |
| //......................................................................... | |
| #define PROP_HANDLE_BOUND_CELL 1 | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::table; | |
| using namespace ::com::sun::star::text; | |
| using namespace ::com::sun::star::sheet; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::util; | |
| using namespace ::com::sun::star::form::binding; | |
| //===================================================================== | |
| //= OCellValueBinding | |
| //===================================================================== | |
| DBG_NAME( OCellValueBinding ) | |
| //--------------------------------------------------------------------- | |
| #ifdef DBG_UTIL | |
| const char* OCellValueBinding::checkConsistency_static( const void* _pThis ) | |
| { | |
| return static_cast< const OCellValueBinding* >( _pThis )->checkConsistency( ); | |
| } | |
| const char* OCellValueBinding::checkConsistency( ) const | |
| { | |
| const char* pAssertion = NULL; | |
| if ( m_xCellText.is() && !m_xCell.is() ) | |
| // there are places (e.g. getSupportedTypes) which rely on the fact | |
| // that m_xCellText.is() implies m_xCell.is() | |
| pAssertion = "cell references inconsistent!"; | |
| // TODO: place any additional checks here to ensure consistency of this instance | |
| return pAssertion; | |
| } | |
| #endif | |
| //--------------------------------------------------------------------- | |
| OCellValueBinding::OCellValueBinding( const Reference< XSpreadsheetDocument >& _rxDocument, sal_Bool _bListPos ) | |
| :OCellValueBinding_Base( m_aMutex ) | |
| ,OCellValueBinding_PBase( OCellValueBinding_Base::rBHelper ) | |
| ,m_xDocument( _rxDocument ) | |
| ,m_aModifyListeners( m_aMutex ) | |
| ,m_bInitialized( sal_False ) | |
| ,m_bListPos( _bListPos ) | |
| { | |
| DBG_CTOR( OCellValueBinding, checkConsistency_static ); | |
| // register our property at the base class | |
| CellAddress aInitialPropValue; | |
| registerPropertyNoMember( | |
| ::rtl::OUString::createFromAscii( "BoundCell" ), | |
| PROP_HANDLE_BOUND_CELL, | |
| PropertyAttribute::BOUND | PropertyAttribute::READONLY, | |
| ::getCppuType( &aInitialPropValue ), | |
| &aInitialPropValue | |
| ); | |
| // TODO: implement a ReadOnly property as required by the service, | |
| // which probably maps to the cell being locked | |
| } | |
| //--------------------------------------------------------------------- | |
| OCellValueBinding::~OCellValueBinding( ) | |
| { | |
| if ( !OCellValueBinding_Base::rBHelper.bDisposed ) | |
| { | |
| acquire(); // prevent duplicate dtor | |
| dispose(); | |
| } | |
| DBG_DTOR( OCellValueBinding, checkConsistency_static ); | |
| } | |
| //-------------------------------------------------------------------- | |
| IMPLEMENT_FORWARD_XINTERFACE2( OCellValueBinding, OCellValueBinding_Base, OCellValueBinding_PBase ) | |
| //-------------------------------------------------------------------- | |
| IMPLEMENT_FORWARD_XTYPEPROVIDER2( OCellValueBinding, OCellValueBinding_Base, OCellValueBinding_PBase ) | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::disposing() | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| Reference<XModifyBroadcaster> xBroadcaster( m_xCell, UNO_QUERY ); | |
| if ( xBroadcaster.is() ) | |
| { | |
| xBroadcaster->removeModifyListener( this ); | |
| } | |
| // OCellValueBinding_Base::disposing(); | |
| WeakAggComponentImplHelperBase::disposing(); | |
| // TODO: clean up here whatever you need to clean up (e.g. deregister as XEventListener | |
| // for the cell) | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XPropertySetInfo > SAL_CALL OCellValueBinding::getPropertySetInfo( ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| return createPropertySetInfo( getInfoHelper() ) ; | |
| } | |
| //-------------------------------------------------------------------- | |
| ::cppu::IPropertyArrayHelper& SAL_CALL OCellValueBinding::getInfoHelper() | |
| { | |
| return *OCellValueBinding_PABase::getArrayHelper(); | |
| } | |
| //-------------------------------------------------------------------- | |
| ::cppu::IPropertyArrayHelper* OCellValueBinding::createArrayHelper( ) const | |
| { | |
| Sequence< Property > aProps; | |
| describeProperties( aProps ); | |
| return new ::cppu::OPropertyArrayHelper(aProps); | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| DBG_ASSERT( _nHandle == PROP_HANDLE_BOUND_CELL, "OCellValueBinding::getFastPropertyValue: invalid handle!" ); | |
| // we only have this one property .... | |
| (void)_nHandle; // avoid warning in product version | |
| _rValue.clear(); | |
| Reference< XCellAddressable > xCellAddress( m_xCell, UNO_QUERY ); | |
| if ( xCellAddress.is() ) | |
| _rValue <<= xCellAddress->getCellAddress( ); | |
| } | |
| //-------------------------------------------------------------------- | |
| Sequence< Type > SAL_CALL OCellValueBinding::getSupportedValueTypes( ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| checkDisposed( ); | |
| checkInitialized( ); | |
| sal_Int32 nCount = m_xCellText.is() ? 3 : m_xCell.is() ? 1 : 0; | |
| if ( m_bListPos ) | |
| ++nCount; | |
| Sequence< Type > aTypes( nCount ); | |
| if ( m_xCell.is() ) | |
| { | |
| // an XCell can be used to set/get "double" values | |
| aTypes[0] = ::getCppuType( static_cast< double* >( NULL ) ); | |
| if ( m_xCellText.is() ) | |
| { | |
| // an XTextRange can be used to set/get "string" values | |
| aTypes[1] = ::getCppuType( static_cast< ::rtl::OUString* >( NULL ) ); | |
| // and additionally, we use it to handle booleans | |
| aTypes[2] = ::getCppuType( static_cast< sal_Bool* >( NULL ) ); | |
| } | |
| // add sal_Int32 only if constructed as ListPositionCellBinding | |
| if ( m_bListPos ) | |
| aTypes[nCount-1] = ::getCppuType( static_cast< sal_Int32* >( NULL ) ); | |
| } | |
| return aTypes; | |
| } | |
| //-------------------------------------------------------------------- | |
| sal_Bool SAL_CALL OCellValueBinding::supportsType( const Type& aType ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| checkDisposed( ); | |
| checkInitialized( ); | |
| // look up in our sequence | |
| Sequence< Type > aSupportedTypes( getSupportedValueTypes() ); | |
| const Type* pTypes = aSupportedTypes.getConstArray(); | |
| const Type* pTypesEnd = aSupportedTypes.getConstArray() + aSupportedTypes.getLength(); | |
| while ( pTypes != pTypesEnd ) | |
| if ( aType.equals( *pTypes++ ) ) | |
| return sal_True; | |
| return sal_False; | |
| } | |
| //-------------------------------------------------------------------- | |
| Any SAL_CALL OCellValueBinding::getValue( const Type& aType ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| checkDisposed( ); | |
| checkInitialized( ); | |
| checkValueType( aType ); | |
| Any aReturn; | |
| switch ( aType.getTypeClass() ) | |
| { | |
| case TypeClass_STRING: | |
| DBG_ASSERT( m_xCellText.is(), "OCellValueBinding::getValue: don't have a text!" ); | |
| if ( m_xCellText.is() ) | |
| aReturn <<= m_xCellText->getString(); | |
| else | |
| aReturn <<= ::rtl::OUString(); | |
| break; | |
| case TypeClass_BOOLEAN: | |
| DBG_ASSERT( m_xCell.is(), "OCellValueBinding::getValue: don't have a double value supplier!" ); | |
| if ( m_xCell.is() ) | |
| { | |
| // check if the cell has a numeric value (this might go into a helper function): | |
| sal_Bool bHasValue = sal_False; | |
| CellContentType eCellType = m_xCell->getType(); | |
| if ( eCellType == CellContentType_VALUE ) | |
| bHasValue = sal_True; | |
| else if ( eCellType == CellContentType_FORMULA ) | |
| { | |
| // check if the formula result is a value | |
| if ( m_xCell->getError() == 0 ) | |
| { | |
| Reference<XPropertySet> xProp( m_xCell, UNO_QUERY ); | |
| if ( xProp.is() ) | |
| { | |
| CellContentType eResultType; | |
| if ( (xProp->getPropertyValue(::rtl::OUString::createFromAscii( "FormulaResultType" ) ) >>= eResultType) && eResultType == CellContentType_VALUE ) | |
| bHasValue = sal_True; | |
| } | |
| } | |
| } | |
| if ( bHasValue ) | |
| { | |
| // 0 is "unchecked", any other value is "checked", regardless of number format | |
| double nCellValue = m_xCell->getValue(); | |
| sal_Bool bBoolValue = ( nCellValue != 0.0 ); | |
| aReturn <<= bBoolValue; | |
| } | |
| // empty cells, text cells and text or error formula results: leave return value empty | |
| } | |
| break; | |
| case TypeClass_DOUBLE: | |
| DBG_ASSERT( m_xCell.is(), "OCellValueBinding::getValue: don't have a double value supplier!" ); | |
| if ( m_xCell.is() ) | |
| aReturn <<= m_xCell->getValue(); | |
| else | |
| aReturn <<= (double)0; | |
| break; | |
| case TypeClass_LONG: | |
| DBG_ASSERT( m_xCell.is(), "OCellValueBinding::getValue: don't have a double value supplier!" ); | |
| if ( m_xCell.is() ) | |
| { | |
| // The list position value in the cell is 1-based. | |
| // We subtract 1 from any cell value (no special handling for 0 or negative values). | |
| sal_Int32 nValue = (sal_Int32) rtl::math::approxFloor( m_xCell->getValue() ); | |
| --nValue; | |
| aReturn <<= nValue; | |
| } | |
| else | |
| aReturn <<= (sal_Int32)0; | |
| break; | |
| default: | |
| DBG_ERROR( "OCellValueBinding::getValue: unreachable code!" ); | |
| // a type other than double and string should never have survived the checkValueType | |
| // above | |
| } | |
| return aReturn; | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::setValue( const Any& aValue ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| checkDisposed( ); | |
| checkInitialized( ); | |
| if ( aValue.hasValue() ) | |
| checkValueType( aValue.getValueType() ); | |
| switch ( aValue.getValueType().getTypeClass() ) | |
| { | |
| case TypeClass_STRING: | |
| { | |
| DBG_ASSERT( m_xCellText.is(), "OCellValueBinding::setValue: don't have a text!" ); | |
| ::rtl::OUString sText; | |
| aValue >>= sText; | |
| if ( m_xCellText.is() ) | |
| m_xCellText->setString( sText ); | |
| } | |
| break; | |
| case TypeClass_BOOLEAN: | |
| { | |
| DBG_ASSERT( m_xCell.is(), "OCellValueBinding::setValue: don't have a double value supplier!" ); | |
| // boolean is stored as values 0 or 1 | |
| // TODO: set the number format to boolean if no format is set? | |
| sal_Bool bValue( sal_False ); | |
| aValue >>= bValue; | |
| double nCellValue = bValue ? 1.0 : 0.0; | |
| if ( m_xCell.is() ) | |
| m_xCell->setValue( nCellValue ); | |
| setBooleanFormat(); | |
| } | |
| break; | |
| case TypeClass_DOUBLE: | |
| { | |
| DBG_ASSERT( m_xCell.is(), "OCellValueBinding::setValue: don't have a double value supplier!" ); | |
| double nValue = 0; | |
| aValue >>= nValue; | |
| if ( m_xCell.is() ) | |
| m_xCell->setValue( nValue ); | |
| } | |
| break; | |
| case TypeClass_LONG: | |
| { | |
| DBG_ASSERT( m_xCell.is(), "OCellValueBinding::setValue: don't have a double value supplier!" ); | |
| sal_Int32 nValue = 0; | |
| aValue >>= nValue; // list index from control layer (0-based) | |
| ++nValue; // the list position value in the cell is 1-based | |
| if ( m_xCell.is() ) | |
| m_xCell->setValue( nValue ); | |
| } | |
| break; | |
| case TypeClass_VOID: | |
| { | |
| // #N/A error value can only be set using XCellRangeData | |
| Reference<XCellRangeData> xData( m_xCell, UNO_QUERY ); | |
| DBG_ASSERT( xData.is(), "OCellValueBinding::setValue: don't have XCellRangeData!" ); | |
| if ( xData.is() ) | |
| { | |
| Sequence<Any> aInner(1); // one empty element | |
| Sequence< Sequence<Any> > aOuter( &aInner, 1 ); // one row | |
| xData->setDataArray( aOuter ); | |
| } | |
| } | |
| break; | |
| default: | |
| DBG_ERROR( "OCellValueBinding::setValue: unreachable code!" ); | |
| // a type other than double and string should never have survived the checkValueType | |
| // above | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void OCellValueBinding::setBooleanFormat() | |
| { | |
| // set boolean number format if not already set | |
| ::rtl::OUString sPropName( ::rtl::OUString::createFromAscii( "NumberFormat" ) ); | |
| Reference<XPropertySet> xCellProp( m_xCell, UNO_QUERY ); | |
| Reference<XNumberFormatsSupplier> xSupplier( m_xDocument, UNO_QUERY ); | |
| if ( xSupplier.is() && xCellProp.is() ) | |
| { | |
| Reference<XNumberFormats> xFormats(xSupplier->getNumberFormats()); | |
| Reference<XNumberFormatTypes> xTypes( xFormats, UNO_QUERY ); | |
| if ( xTypes.is() ) | |
| { | |
| Locale aLocale; | |
| sal_Bool bWasBoolean = sal_False; | |
| sal_Int32 nOldIndex = ::comphelper::getINT32( xCellProp->getPropertyValue( sPropName ) ); | |
| Reference<XPropertySet> xOldFormat; | |
| try | |
| { | |
| xOldFormat.set(xFormats->getByKey( nOldIndex )); | |
| } | |
| catch ( Exception& ) | |
| { | |
| // non-existing format - can happen, use defaults | |
| } | |
| if ( xOldFormat.is() ) | |
| { | |
| // use the locale of the existing format | |
| xOldFormat->getPropertyValue( ::rtl::OUString::createFromAscii( "Locale" ) ) >>= aLocale; | |
| sal_Int16 nOldType = ::comphelper::getINT16( | |
| xOldFormat->getPropertyValue( ::rtl::OUString::createFromAscii( "Type" ) ) ); | |
| if ( nOldType & NumberFormat::LOGICAL ) | |
| bWasBoolean = sal_True; | |
| } | |
| if ( !bWasBoolean ) | |
| { | |
| sal_Int32 nNewIndex = xTypes->getStandardFormat( NumberFormat::LOGICAL, aLocale ); | |
| xCellProp->setPropertyValue( sPropName, makeAny( nNewIndex ) ); | |
| } | |
| } | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void OCellValueBinding::checkDisposed( ) const | |
| { | |
| if ( OCellValueBinding_Base::rBHelper.bInDispose || OCellValueBinding_Base::rBHelper.bDisposed ) | |
| throw DisposedException(); | |
| // TODO: is it worth having an error message here? | |
| } | |
| //-------------------------------------------------------------------- | |
| void OCellValueBinding::checkInitialized() | |
| { | |
| if ( !m_bInitialized ) | |
| throw RuntimeException(); | |
| // TODO: error message | |
| } | |
| //-------------------------------------------------------------------- | |
| void OCellValueBinding::checkValueType( const Type& _rType ) const | |
| { | |
| OCellValueBinding* pNonConstThis = const_cast< OCellValueBinding* >( this ); | |
| if ( !pNonConstThis->supportsType( _rType ) ) | |
| { | |
| ::rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM( "The given type (" ) ); | |
| sMessage += _rType.getTypeName(); | |
| sMessage += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ") is not supported by this binding." ) ); | |
| // TODO: localize this error message | |
| throw IncompatibleTypesException( sMessage, *pNonConstThis ); | |
| // TODO: alternatively use a type converter service for this? | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString SAL_CALL OCellValueBinding::getImplementationName( ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.sheet.OCellValueBinding" ) ); | |
| } | |
| //-------------------------------------------------------------------- | |
| sal_Bool SAL_CALL OCellValueBinding::supportsService( const ::rtl::OUString& _rServiceName ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| Sequence< ::rtl::OUString > aSupportedServices( getSupportedServiceNames() ); | |
| const ::rtl::OUString* pLookup = aSupportedServices.getConstArray(); | |
| const ::rtl::OUString* pLookupEnd = aSupportedServices.getConstArray() + aSupportedServices.getLength(); | |
| while ( pLookup != pLookupEnd ) | |
| if ( *pLookup++ == _rServiceName ) | |
| return sal_True; | |
| return sal_False; | |
| } | |
| //-------------------------------------------------------------------- | |
| Sequence< ::rtl::OUString > SAL_CALL OCellValueBinding::getSupportedServiceNames( ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| Sequence< ::rtl::OUString > aServices( m_bListPos ? 3 : 2 ); | |
| aServices[ 0 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.table.CellValueBinding" ) ); | |
| aServices[ 1 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.form.binding.ValueBinding" ) ); | |
| if ( m_bListPos ) | |
| aServices[ 2 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.table.ListPositionCellBinding" ) ); | |
| return aServices; | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::addModifyListener( const Reference< XModifyListener >& _rxListener ) | |
| { | |
| if ( _rxListener.is() ) | |
| m_aModifyListeners.addInterface( _rxListener ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::removeModifyListener( const Reference< XModifyListener >& _rxListener ) | |
| { | |
| if ( _rxListener.is() ) | |
| m_aModifyListeners.removeInterface( _rxListener ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void OCellValueBinding::notifyModified() | |
| { | |
| EventObject aEvent; | |
| aEvent.Source.set(*this); | |
| ::cppu::OInterfaceIteratorHelper aIter( m_aModifyListeners ); | |
| while ( aIter.hasMoreElements() ) | |
| { | |
| try | |
| { | |
| static_cast< XModifyListener* >( aIter.next() )->modified( aEvent ); | |
| } | |
| catch( const RuntimeException& ) | |
| { | |
| // silent this | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_ERROR( "OCellValueBinding::notifyModified: caught a (non-runtime) exception!" ); | |
| } | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::modified( const EventObject& /* aEvent */ ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| notifyModified(); | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::disposing( const EventObject& aEvent ) | |
| { | |
| DBG_CHKTHIS( OCellValueBinding, checkConsistency_static ); | |
| Reference<XInterface> xCellInt( m_xCell, UNO_QUERY ); | |
| if ( xCellInt == aEvent.Source ) | |
| { | |
| // release references to cell object | |
| m_xCell.clear(); | |
| m_xCellText.clear(); | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OCellValueBinding::initialize( const Sequence< Any >& _rArguments ) | |
| { | |
| if ( m_bInitialized ) | |
| throw Exception(); | |
| // TODO: error message | |
| // get the cell address | |
| CellAddress aAddress; | |
| sal_Bool bFoundAddress = sal_False; | |
| const Any* pLoop = _rArguments.getConstArray(); | |
| const Any* pLoopEnd = _rArguments.getConstArray() + _rArguments.getLength(); | |
| for ( ; ( pLoop != pLoopEnd ) && !bFoundAddress; ++pLoop ) | |
| { | |
| NamedValue aValue; | |
| if ( *pLoop >>= aValue ) | |
| { | |
| if ( aValue.Name.equalsAscii( "BoundCell" ) ) | |
| { | |
| if ( aValue.Value >>= aAddress ) | |
| bFoundAddress = sal_True; | |
| } | |
| } | |
| } | |
| if ( !bFoundAddress ) | |
| // TODO: error message | |
| throw Exception(); | |
| // get the cell object | |
| try | |
| { | |
| // first the sheets collection | |
| Reference< XIndexAccess > xSheets; | |
| if ( m_xDocument.is() ) | |
| xSheets.set(xSheets.query( m_xDocument->getSheets( ) )); | |
| DBG_ASSERT( xSheets.is(), "OCellValueBinding::initialize: could not retrieve the sheets!" ); | |
| if ( xSheets.is() ) | |
| { | |
| // the concrete sheet | |
| Reference< XCellRange > xSheet(xSheets->getByIndex( aAddress.Sheet ), UNO_QUERY); | |
| DBG_ASSERT( xSheet.is(), "OCellValueBinding::initialize: NULL sheet, but no exception!" ); | |
| // the concrete cell | |
| if ( xSheet.is() ) | |
| { | |
| m_xCell.set(xSheet->getCellByPosition( aAddress.Column, aAddress.Row )); | |
| Reference< XCellAddressable > xAddressAccess( m_xCell, UNO_QUERY ); | |
| DBG_ASSERT( xAddressAccess.is(), "OCellValueBinding::initialize: either NULL cell, or cell without address access!" ); | |
| } | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_ERROR( "OCellValueBinding::initialize: caught an exception while retrieving the cell object!" ); | |
| } | |
| if ( !m_xCell.is() ) | |
| throw Exception(); | |
| // TODO error message | |
| m_xCellText.set(m_xCellText.query( m_xCell )); | |
| Reference<XModifyBroadcaster> xBroadcaster( m_xCell, UNO_QUERY ); | |
| if ( xBroadcaster.is() ) | |
| { | |
| xBroadcaster->addModifyListener( this ); | |
| } | |
| // TODO: add as XEventListener to the cell, so we get notified when it dies, | |
| // and can dispose ourself then | |
| // TODO: somehow add as listener so we get notified when the address of the cell changes | |
| // We need to forward this as change in our BoundCell property to our property change listeners | |
| // TODO: be an XModifyBroadcaster, so that changes in our cell can be notified | |
| // to the BindableValue which is/will be bound to this instance. | |
| m_bInitialized = sal_True; | |
| // TODO: place your code here | |
| } | |
| //......................................................................... | |
| } // namespace calc | |
| //......................................................................... |