sc/source/ui/unoobj/celllistsource.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 "celllistsource.hxx"
  21 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  22 #include <com/sun/star/lang/NotInitializedException.hpp>
  23 #include <com/sun/star/lang/NullPointerException.hpp>
  24 #include <com/sun/star/table/XCellRange.hpp>
  25 #include <com/sun/star/text/XTextRange.hpp>
  26 #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
  27 #include <com/sun/star/sheet/FormulaResult.hpp>
  28 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  29 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  30 #include <com/sun/star/container/XIndexAccess.hpp>
  31 #include <com/sun/star/beans/PropertyAttribute.hpp>
  32 #include <com/sun/star/beans/NamedValue.hpp>
  33 #include <cppuhelper/supportsservice.hxx>
  34 #include <comphelper/diagnose_ex.hxx>
  35
  36 namespace calc
  37 {
  38
  39 #define PROP_HANDLE_RANGE_ADDRESS  1
  40
  41     using namespace ::com::sun::star::uno;
  42     using namespace ::com::sun::star::lang;
  43     using namespace ::com::sun::star::table;
  44     using namespace ::com::sun::star::text;
  45     using namespace ::com::sun::star::sheet;
  46     using namespace ::com::sun::star::container;
  47     using namespace ::com::sun::star::beans;
  48     using namespace ::com::sun::star::util;
  49     using namespace ::com::sun::star::form::binding;
  50
  51     OCellListSource::OCellListSource( const Reference< XSpreadsheetDocument >& _rxDocument )
  52         :m_xDocument( _rxDocument )
  53         ,m_bInitialized( false )
  54     {
  55         OSL_PRECOND( m_xDocument.is(), "OCellListSource::OCellListSource: invalid document!" );
  56
  57         // register our property at the base class
  58         registerPropertyNoMember(
  59             u"CellRange"_ustr,
  60             PROP_HANDLE_RANGE_ADDRESS,
  61             PropertyAttribute::BOUND | PropertyAttribute::READONLY,
  62             cppu::UnoType<CellRangeAddress>::get(),
  63             css::uno::Any(CellRangeAddress())
  64         );
  65     }
  66
  67     OCellListSource::~OCellListSource( )
  68     {
  69         if ( !m_bDisposed )
  70         {
  71             acquire();  // prevent duplicate dtor
  72             dispose();
  73         }
  74     }
  75
  76     IMPLEMENT_FORWARD_XINTERFACE2( OCellListSource, OCellListSource_Base, OCellListSource_PBase )
  77
  78     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OCellListSource, OCellListSource_Base, OCellListSource_PBase )
  79
  80     void OCellListSource::disposing(std::unique_lock<std::mutex>& rGuard)
  81     {
  82         Reference<XModifyBroadcaster> xBroadcaster( m_xRange, UNO_QUERY );
  83         if ( xBroadcaster.is() )
  84         {
  85             xBroadcaster->removeModifyListener( this );
  86         }
  87
  88         EventObject aDisposeEvent( *this );
  89         m_aListEntryListeners.disposeAndClear( rGuard, aDisposeEvent );
  90
  91         WeakComponentImplHelperBase::disposing(rGuard);
  92
  93         // TODO: clean up here whatever you need to clean up (e.g. revoking listeners etc.)
  94     }
  95
  96     Reference< XPropertySetInfo > SAL_CALL OCellListSource::getPropertySetInfo(  )
  97     {
  98         return createPropertySetInfo( getInfoHelper() ) ;
  99     }
 100
 101     ::cppu::IPropertyArrayHelper& OCellListSource::getInfoHelper()
 102     {
 103         return *OCellListSource_PABase::getArrayHelper();
 104     }
 105
 106     ::cppu::IPropertyArrayHelper* OCellListSource::createArrayHelper( ) const
 107     {
 108         Sequence< Property > aProps;
 109         describeProperties( aProps );
 110         return new ::cppu::OPropertyArrayHelper(aProps);
 111     }
 112
 113     void OCellListSource::getFastPropertyValue( std::unique_lock<std::mutex>& /*rGuard*/, Any& _rValue, sal_Int32 _nHandle ) const
 114     {
 115         OSL_ENSURE( _nHandle == PROP_HANDLE_RANGE_ADDRESS, "OCellListSource::getFastPropertyValue: invalid handle!" );
 116             // we only have this one property...
 117
 118         _rValue <<= getRangeAddress( );
 119     }
 120
 121     void OCellListSource::checkInitialized()
 122     {
 123         if ( !m_bInitialized )
 124             throw NotInitializedException(u"CellListSource is not initialized"_ustr, getXWeak());
 125     }
 126
 127     OUString SAL_CALL OCellListSource::getImplementationName(  )
 128     {
 129         return u"com.sun.star.comp.sheet.OCellListSource"_ustr;
 130     }
 131
 132     sal_Bool SAL_CALL OCellListSource::supportsService( const OUString& _rServiceName )
 133     {
 134         return cppu::supportsService(this, _rServiceName);
 135     }
 136
 137     Sequence< OUString > SAL_CALL OCellListSource::getSupportedServiceNames(  )
 138     {
 139         return {u"com.sun.star.table.CellRangeListSource"_ustr,
 140                 u"com.sun.star.form.binding.ListEntrySource"_ustr};
 141     }
 142
 143     CellRangeAddress OCellListSource::getRangeAddress( ) const
 144     {
 145         OSL_PRECOND( m_xRange.is(), "OCellListSource::getRangeAddress: invalid range!" );
 146
 147         CellRangeAddress aAddress;
 148         Reference< XCellRangeAddressable > xRangeAddress( m_xRange, UNO_QUERY );
 149         if ( xRangeAddress.is() )
 150             aAddress = xRangeAddress->getRangeAddress( );
 151         return aAddress;
 152     }
 153
 154     OUString OCellListSource::getCellTextContent_noCheck( std::unique_lock<std::mutex>& /*rGuard*/, sal_Int32 _nRangeRelativeRow, css::uno::Any* pAny )
 155     {
 156         OUString sText;
 157
 158         OSL_PRECOND( m_xRange.is(), "OCellListSource::getRangeAddress: invalid range!" );
 159
 160         if (!m_xRange.is())
 161             return sText;
 162
 163         Reference< XCell > xCell( m_xRange->getCellByPosition( 0, _nRangeRelativeRow ));
 164         if (!xCell.is())
 165         {
 166             if (pAny)
 167                 *pAny <<= sText;
 168             return sText;
 169         }
 170
 171         Reference< XTextRange > xCellText;
 172         xCellText.set( xCell, UNO_QUERY);
 173
 174         if (xCellText.is())
 175             sText = xCellText->getString();     // formatted output string
 176
 177         if (pAny)
 178         {
 179             switch (xCell->getType())
 180             {
 181                 case CellContentType_VALUE:
 182                     *pAny <<= xCell->getValue();
 183                 break;
 184                 case CellContentType_TEXT:
 185                     *pAny <<= sText;
 186                 break;
 187                 case CellContentType_FORMULA:
 188                     if (xCell->getError())
 189                         *pAny <<= sText;    // Err:... or #...!
 190                     else
 191                     {
 192                         Reference< XPropertySet > xProp( xCell, UNO_QUERY);
 193                         if (xProp.is())
 194                         {
 195                             sal_Int32 nResultType;
 196                             if ((xProp->getPropertyValue(u"FormulaResultType2"_ustr) >>= nResultType) &&
 197                                     nResultType == FormulaResult::VALUE)
 198                                 *pAny <<= xCell->getValue();
 199                             else
 200                                 *pAny <<= sText;
 201                         }
 202                     }
 203                 break;
 204                 case CellContentType_EMPTY:
 205                     *pAny <<= OUString();
 206                 break;
 207                 default:
 208                     ;   // nothing, if actually occurred it would result in #N/A being displayed if selected
 209             }
 210         }
 211
 212         return sText;
 213     }
 214
 215     sal_Int32 SAL_CALL OCellListSource::getListEntryCount(  )
 216     {
 217         std::unique_lock<std::mutex> aGuard( m_aMutex );
 218         throwIfDisposed(aGuard);
 219         checkInitialized();
 220         return getListEntryCount(aGuard);
 221     }
 222
 223     sal_Int32 OCellListSource::getListEntryCount( std::unique_lock<std::mutex>& /*rGuard*/ )
 224     {
 225         CellRangeAddress aAddress( getRangeAddress( ) );
 226         return aAddress.EndRow - aAddress.StartRow + 1;
 227     }
 228
 229     OUString SAL_CALL OCellListSource::getListEntry( sal_Int32 _nPosition )
 230     {
 231         std::unique_lock<std::mutex> aGuard( m_aMutex );
 232         throwIfDisposed(aGuard);
 233         checkInitialized();
 234
 235         if ( _nPosition >= getListEntryCount() )
 236             throw IndexOutOfBoundsException();
 237
 238         return getCellTextContent_noCheck( aGuard, _nPosition, nullptr );
 239     }
 240
 241     Sequence< OUString > SAL_CALL OCellListSource::getAllListEntries(  )
 242     {
 243         std::unique_lock<std::mutex> aGuard( m_aMutex );
 244         throwIfDisposed(aGuard);
 245         checkInitialized();
 246
 247         Sequence< OUString > aAllEntries( getListEntryCount(aGuard) );
 248         OUString* pAllEntries = aAllEntries.getArray();
 249         for ( sal_Int32 i = 0; i < aAllEntries.getLength(); ++i )
 250         {
 251             *pAllEntries++ = getCellTextContent_noCheck( aGuard, i, nullptr );
 252         }
 253
 254         return aAllEntries;
 255     }
 256
 257     Sequence< OUString > SAL_CALL OCellListSource::getAllListEntriesTyped( Sequence< Any >& rDataValues )
 258     {
 259         std::unique_lock<std::mutex> aGuard( m_aMutex );
 260         throwIfDisposed(aGuard);
 261         checkInitialized();
 262
 263         const sal_Int32 nCount = getListEntryCount(aGuard);
 264         Sequence< OUString > aAllEntries( nCount );
 265         rDataValues = Sequence< Any >( nCount );
 266         OUString* pAllEntries = aAllEntries.getArray();
 267         Any* pDataValues = rDataValues.getArray();
 268         for ( sal_Int32 i = 0; i < nCount; ++i )
 269         {
 270             *pAllEntries++ = getCellTextContent_noCheck( aGuard, i, pDataValues++ );
 271         }
 272
 273         return aAllEntries;
 274     }
 275
 276     void SAL_CALL OCellListSource::addListEntryListener( const Reference< XListEntryListener >& _rxListener )
 277     {
 278         std::unique_lock<std::mutex> aGuard( m_aMutex );
 279         throwIfDisposed(aGuard);
 280         checkInitialized();
 281
 282         if ( !_rxListener.is() )
 283             throw NullPointerException();
 284
 285         m_aListEntryListeners.addInterface( aGuard, _rxListener );
 286     }
 287
 288     void SAL_CALL OCellListSource::removeListEntryListener( const Reference< XListEntryListener >& _rxListener )
 289     {
 290         std::unique_lock<std::mutex> aGuard( m_aMutex );
 291         throwIfDisposed(aGuard);
 292         checkInitialized();
 293
 294         if ( !_rxListener.is() )
 295             throw NullPointerException();
 296
 297         m_aListEntryListeners.removeInterface( aGuard, _rxListener );
 298     }
 299
 300     void SAL_CALL OCellListSource::modified( const EventObject& /* aEvent */ )
 301     {
 302         notifyModified();
 303     }
 304
 305     void OCellListSource::notifyModified()
 306     {
 307         std::unique_lock<std::mutex> aGuard( m_aMutex );
 308         EventObject aEvent;
 309         aEvent.Source.set(*this);
 310
 311         m_aListEntryListeners.forEach(aGuard,
 312             [&aEvent] (const css::uno::Reference<css::form::binding::XListEntryListener>& l)
 313             {
 314                 try
 315                 {
 316                     l->allEntriesChanged( aEvent );
 317                 }
 318                 catch( const RuntimeException& )
 319                 {
 320                     // silent this
 321                 }
 322                 catch( const Exception& )
 323                 {
 324                     TOOLS_WARN_EXCEPTION( "sc", "OCellListSource::notifyModified: caught a (non-runtime) exception!" );
 325                 }
 326             });
 327     }
 328
 329     void SAL_CALL OCellListSource::disposing( const EventObject& aEvent )
 330     {
 331         Reference<XInterface> xRangeInt( m_xRange, UNO_QUERY );
 332         if ( xRangeInt == aEvent.Source )
 333         {
 334             // release references to range object
 335             m_xRange.clear();
 336         }
 337     }
 338
 339     void SAL_CALL OCellListSource::initialize( const Sequence< Any >& _rArguments )
 340     {
 341         if ( m_bInitialized )
 342             throw RuntimeException(u"CellListSource is already initialized"_ustr, getXWeak());
 343
 344         // get the cell address
 345         CellRangeAddress aRangeAddress;
 346         bool bFoundAddress = false;
 347
 348         for ( const Any& rArg : _rArguments )
 349         {
 350             NamedValue aValue;
 351             if ( rArg >>= aValue )
 352             {
 353                 if ( aValue.Name == "CellRange" )
 354                 {
 355                     if ( aValue.Value >>= aRangeAddress )
 356                     {
 357                         bFoundAddress = true;
 358                         break;
 359                     }
 360                 }
 361             }
 362         }
 363
 364         if ( !bFoundAddress )
 365             throw RuntimeException(u"Cell not found"_ustr, getXWeak());
 366
 367         // determine the range we're bound to
 368         try
 369         {
 370             if ( m_xDocument.is() )
 371             {
 372                 // first the sheets collection
 373                 Reference< XIndexAccess > xSheets(m_xDocument->getSheets( ), UNO_QUERY);
 374                 OSL_ENSURE( xSheets.is(), "OCellListSource::initialize: could not retrieve the sheets!" );
 375
 376                 if ( xSheets.is() )
 377                 {
 378                     // the concrete sheet
 379                     Reference< XCellRange > xSheet(xSheets->getByIndex( aRangeAddress.Sheet ), UNO_QUERY);
 380                     OSL_ENSURE( xSheet.is(), "OCellListSource::initialize: NULL sheet, but no exception!" );
 381
 382                     // the concrete cell
 383                     if ( xSheet.is() )
 384                     {
 385                         m_xRange.set(xSheet->getCellRangeByPosition(
 386                             aRangeAddress.StartColumn, aRangeAddress.StartRow,
 387                             aRangeAddress.EndColumn, aRangeAddress.EndRow));
 388                         OSL_ENSURE( Reference< XCellRangeAddressable >( m_xRange, UNO_QUERY ).is(), "OCellListSource::initialize: either NULL range, or cell without address access!" );
 389                     }
 390                 }
 391             }
 392         }
 393         catch( const Exception& )
 394         {
 395             TOOLS_WARN_EXCEPTION( "sc", "OCellListSource::initialize: caught an exception while retrieving the cell object!" );
 396         }
 397
 398         if ( !m_xRange.is() )
 399             throw RuntimeException(u"Failed to retrieve cell range"_ustr, getXWeak());
 400
 401         Reference<XModifyBroadcaster> xBroadcaster( m_xRange, UNO_QUERY );
 402         if ( xBroadcaster.is() )
 403         {
 404             xBroadcaster->addModifyListener( this );
 405         }
 406
 407         // TODO: add as XEventListener to the cell range, so we get notified when it dies,
 408         // and can dispose ourself then
 409
 410         // TODO: somehow add as listener so we get notified when the address of the cell range changes
 411         // We need to forward this as change in our CellRange property to our property change listeners
 412
 413         // TODO: somehow add as listener to the cells in the range, so that we get notified
 414         // when their content changes. We need to forward this to our list entry listeners then
 415
 416         // TODO: somehow add as listener so that we get notified of insertions and removals of rows in our
 417         // range. In this case, we need to fire a change in our CellRange property, and additionally
 418         // notify our XListEntryListeners
 419
 420         m_bInitialized = true;
 421     }
 422
 423 }   // namespace calc
 424
 425 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */