LCOV - code coverage report
Current view: top level - toolkit/source/controls/grid - sortablegriddatamodel.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 246 355 69.3 %
Date: 2014-11-03 Functions: 46 60 76.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "initguard.hxx"
      21             : 
      22             : #include <com/sun/star/i18n/Collator.hpp>
      23             : #include <com/sun/star/i18n/XCollator.hpp>
      24             : #include <com/sun/star/lang/IllegalArgumentException.hpp>
      25             : #include <com/sun/star/lang/XInitialization.hpp>
      26             : #include <com/sun/star/lang/XServiceInfo.hpp>
      27             : #include <com/sun/star/ucb/AlreadyInitializedException.hpp>
      28             : #include <com/sun/star/uno/XComponentContext.hpp>
      29             : #include <com/sun/star/awt/grid/XGridDataListener.hpp>
      30             : #include <com/sun/star/awt/grid/XSortableMutableGridDataModel.hpp>
      31             : 
      32             : #include <cppuhelper/basemutex.hxx>
      33             : #include <cppuhelper/compbase3.hxx>
      34             : #include <cppuhelper/implbase1.hxx>
      35             : #include <comphelper/anycompare.hxx>
      36             : #include <cppuhelper/supportsservice.hxx>
      37             : #include <cppuhelper/typeprovider.hxx>
      38             : #include <tools/diagnose_ex.h>
      39             : #include <vcl/svapp.hxx>
      40             : #include <vcl/settings.hxx>
      41             : 
      42             : using namespace css::awt;
      43             : using namespace css::awt::grid;
      44             : using namespace css::i18n;
      45             : using namespace css::lang;
      46             : using namespace css::ucb;
      47             : using namespace css::uno;
      48             : using namespace toolkit;
      49             : 
      50             : namespace {
      51             : 
      52             : class SortableGridDataModel;
      53             : typedef InitGuard< SortableGridDataModel >  MethodGuard;
      54             : 
      55             : typedef ::cppu::WeakComponentImplHelper3    <   css::awt::grid::XSortableMutableGridDataModel
      56             :                                             ,   css::lang::XServiceInfo
      57             :                                             ,   css::lang::XInitialization
      58             :                                             >   SortableGridDataModel_Base;
      59             : typedef ::cppu::ImplHelper1 <   css::awt::grid::XGridDataListener
      60             :                             >   SortableGridDataModel_PrivateBase;
      61             : class SortableGridDataModel :public ::cppu::BaseMutex
      62             :                             ,public SortableGridDataModel_Base
      63             :                             ,public SortableGridDataModel_PrivateBase
      64             : {
      65             : public:
      66             :     SortableGridDataModel( const css::uno::Reference< css::uno::XComponentContext > & rxContext );
      67             :     SortableGridDataModel( SortableGridDataModel const & i_copySource );
      68             : 
      69        1224 :     bool    isInitialized() const { return m_isInitialized; }
      70             : 
      71             : protected:
      72             :     virtual ~SortableGridDataModel();
      73             : 
      74             : public:
      75             :     // XSortableGridData
      76             :     virtual void SAL_CALL sortByColumn( ::sal_Int32 ColumnIndex, sal_Bool SortAscending ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      77             :     virtual void SAL_CALL removeColumnSort(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      78             :     virtual css::beans::Pair< ::sal_Int32, sal_Bool > SAL_CALL getCurrentSortOrder(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      79             : 
      80             :     // XMutableGridDataModel
      81             :     virtual void SAL_CALL addRow( const css::uno::Any& Heading, const css::uno::Sequence< css::uno::Any >& Data ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      82             :     virtual void SAL_CALL addRows( const css::uno::Sequence< css::uno::Any >& Headings, const css::uno::Sequence< css::uno::Sequence< css::uno::Any > >& Data ) throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      83             :     virtual void SAL_CALL insertRow( ::sal_Int32 i_index, const css::uno::Any& i_heading, const css::uno::Sequence< css::uno::Any >& Data ) throw (css::uno::RuntimeException, css::lang::IndexOutOfBoundsException, std::exception) SAL_OVERRIDE;
      84             :     virtual void SAL_CALL insertRows( ::sal_Int32 i_index, const css::uno::Sequence< css::uno::Any>& Headings, const css::uno::Sequence< css::uno::Sequence< css::uno::Any > >& Data ) throw (css::lang::IllegalArgumentException, css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      85             :     virtual void SAL_CALL removeRow( ::sal_Int32 RowIndex ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      86             :     virtual void SAL_CALL removeAllRows(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      87             :     virtual void SAL_CALL updateCellData( ::sal_Int32 ColumnIndex, ::sal_Int32 RowIndex, const css::uno::Any& Value ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      88             :     virtual void SAL_CALL updateRowData( const css::uno::Sequence< ::sal_Int32 >& ColumnIndexes, ::sal_Int32 RowIndex, const css::uno::Sequence< css::uno::Any >& Values ) throw (css::lang::IndexOutOfBoundsException, css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      89             :     virtual void SAL_CALL updateRowHeading( ::sal_Int32 RowIndex, const css::uno::Any& Heading ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      90             :     virtual void SAL_CALL updateCellToolTip( ::sal_Int32 ColumnIndex, ::sal_Int32 RowIndex, const css::uno::Any& Value ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      91             :     virtual void SAL_CALL updateRowToolTip( ::sal_Int32 RowIndex, const css::uno::Any& Value ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      92             :     virtual void SAL_CALL addGridDataListener( const css::uno::Reference< css::awt::grid::XGridDataListener >& Listener ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      93             :     virtual void SAL_CALL removeGridDataListener( const css::uno::Reference< css::awt::grid::XGridDataListener >& Listener ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      94             : 
      95             :     // XGridDataModel
      96             :     virtual ::sal_Int32 SAL_CALL getRowCount() throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      97             :     virtual ::sal_Int32 SAL_CALL getColumnCount() throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      98             :     virtual css::uno::Any SAL_CALL getCellData( ::sal_Int32 Column, ::sal_Int32 RowIndex ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      99             :     virtual css::uno::Any SAL_CALL getCellToolTip( ::sal_Int32 Column, ::sal_Int32 RowIndex ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     100             :     virtual css::uno::Any SAL_CALL getRowHeading( ::sal_Int32 RowIndex ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     101             :     virtual css::uno::Sequence< css::uno::Any > SAL_CALL getRowData( ::sal_Int32 RowIndex ) throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     102             : 
     103             :     // OComponentHelper
     104             :     virtual void SAL_CALL disposing() SAL_OVERRIDE;
     105             : 
     106             :     // XCloneable
     107             :     virtual css::uno::Reference< css::util::XCloneable > SAL_CALL createClone(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     108             : 
     109             :     // XServiceInfo
     110             :     virtual OUString SAL_CALL getImplementationName(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     111             :     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     112             :     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     113             : 
     114             :     // XInitialization
     115             :     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) throw (css::uno::Exception, css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     116             : 
     117             :     // XGridDataListener
     118             :     virtual void SAL_CALL rowsInserted( const css::awt::grid::GridDataEvent& Event ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     119             :     virtual void SAL_CALL rowsRemoved( const css::awt::grid::GridDataEvent& Event ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     120             :     virtual void SAL_CALL dataChanged( const css::awt::grid::GridDataEvent& Event ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     121             :     virtual void SAL_CALL rowHeadingChanged( const css::awt::grid::GridDataEvent& Event ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     122             : 
     123             :     // XEventListener
     124             :     virtual void SAL_CALL disposing( const css::lang::EventObject& i_event ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     125             : 
     126             :     // XInterface
     127             :     virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     128             :     virtual void SAL_CALL acquire(  ) throw () SAL_OVERRIDE;
     129             :     virtual void SAL_CALL release(  ) throw () SAL_OVERRIDE;
     130             : 
     131             :     // XTypeProvider
     132             :     virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     133             :     virtual css::uno::Sequence< ::sal_Int8 > SAL_CALL getImplementationId(  ) throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     134             : 
     135             : private:
     136             :     /** translates the given public index into one to be passed to our delegator
     137             :         @throws css::lang::IndexOutOfBoundsException
     138             :             if the given index does not denote a valid row
     139             :     */
     140             :     ::sal_Int32 impl_getPrivateRowIndex_throw( ::sal_Int32 const i_publicRowIndex ) const;
     141             : 
     142             :     /** translates the given private row index to a public one
     143             :     */
     144             :     ::sal_Int32 impl_getPublicRowIndex_nothrow( ::sal_Int32 const i_privateRowIndex ) const;
     145             : 
     146        1116 :     inline bool impl_isSorted_nothrow() const
     147             :     {
     148        1116 :         return m_currentSortColumn >= 0;
     149             :     }
     150             : 
     151             :     /** rebuilds the index translation structure.
     152             : 
     153             :         Neither <member>m_currentSortColumn</member> nor <member>m_sortAscending</member> are touched by this method.
     154             :         Also, the given column index is not checked, this is the responsibility of the caller.
     155             :     */
     156             :     bool    impl_reIndex_nothrow( ::sal_Int32 const i_columnIndex, bool const i_sortAscending );
     157             : 
     158             :     /** translates the given event, obtained from our delegator, to a version which can be broadcasted to our own
     159             :         clients.
     160             :     */
     161             :     css::awt::grid::GridDataEvent
     162             :             impl_createPublicEvent( css::awt::grid::GridDataEvent const & i_originalEvent ) const;
     163             : 
     164             :     /** broadcasts the given event to our registered XGridDataListeners
     165             :     */
     166             :     void    impl_broadcast(
     167             :                 void ( SAL_CALL css::awt::grid::XGridDataListener::*i_listenerMethod )( const css::awt::grid::GridDataEvent & ),
     168             :                 css::awt::grid::GridDataEvent const & i_publicEvent,
     169             :                 MethodGuard& i_instanceLock
     170             :             );
     171             : 
     172             :     /** rebuilds our indexes, notifying row removal and row addition events
     173             : 
     174             :         First, a rowsRemoved event is notified to our registered listeners. Then, the index translation tables are
     175             :         rebuilt, and a rowsInserted event is notified.
     176             : 
     177             :         Only to be called when we're sorted.
     178             :     */
     179             :     void    impl_rebuildIndexesAndNotify( MethodGuard& i_instanceLock );
     180             : 
     181             :     /** removes the current sorting, and notifies a change of all data
     182             :     */
     183             :     void    impl_removeColumnSort( MethodGuard& i_instanceLock );
     184             : 
     185             :     /** removes the current sorting, without any broadcast
     186             :     */
     187             :     void    impl_removeColumnSort_noBroadcast();
     188             : 
     189             : private:
     190             :     css::uno::Reference< css::uno::XComponentContext >            m_xContext;
     191             :     bool                                                          m_isInitialized;
     192             :     css::uno::Reference< css::awt::grid::XMutableGridDataModel >  m_delegator;
     193             :     css::uno::Reference< css::i18n::XCollator >                   m_collator;
     194             :     ::sal_Int32                                                   m_currentSortColumn;
     195             :     bool                                                    m_sortAscending;
     196             :     ::std::vector< ::sal_Int32 >                                  m_publicToPrivateRowIndex;
     197             :     ::std::vector< ::sal_Int32 >                                  m_privateToPublicRowIndex;
     198             : };
     199             : 
     200             :     namespace
     201             :     {
     202             :         template< class STLCONTAINER >
     203          16 :         static void lcl_clear( STLCONTAINER& i_container )
     204             :         {
     205          16 :             STLCONTAINER empty;
     206          16 :             empty.swap( i_container );
     207          16 :         }
     208             :     }
     209             : 
     210          16 :     SortableGridDataModel::SortableGridDataModel( Reference< XComponentContext > const & rxContext )
     211             :         :SortableGridDataModel_Base( m_aMutex )
     212             :         ,SortableGridDataModel_PrivateBase()
     213             :         ,m_xContext( rxContext )
     214             :         ,m_isInitialized( false )
     215             :         ,m_delegator()
     216             :         ,m_collator()
     217             :         ,m_currentSortColumn( -1 )
     218             :         ,m_sortAscending( true )
     219             :         ,m_publicToPrivateRowIndex()
     220          16 :         ,m_privateToPublicRowIndex()
     221             :     {
     222          16 :     }
     223             : 
     224             : 
     225           2 :     SortableGridDataModel::SortableGridDataModel( SortableGridDataModel const & i_copySource )
     226             :         :cppu::BaseMutex()
     227             :         ,SortableGridDataModel_Base( m_aMutex )
     228             :         ,SortableGridDataModel_PrivateBase()
     229             :         ,m_xContext( i_copySource.m_xContext )
     230             :         ,m_isInitialized( true )
     231             :         ,m_delegator()
     232             :         ,m_collator( i_copySource.m_collator )
     233             :         ,m_currentSortColumn( i_copySource.m_currentSortColumn )
     234             :         ,m_sortAscending( i_copySource.m_sortAscending )
     235             :         ,m_publicToPrivateRowIndex( i_copySource.m_publicToPrivateRowIndex )
     236           2 :         ,m_privateToPublicRowIndex( i_copySource.m_privateToPublicRowIndex )
     237             :     {
     238           2 :         ENSURE_OR_THROW( i_copySource.m_delegator.is(),
     239             :             "not expected to be called for a disposed copy source!" );
     240           2 :         m_delegator.set( i_copySource.m_delegator->createClone(), UNO_QUERY_THROW );
     241           2 :     }
     242             : 
     243             : 
     244          24 :     SortableGridDataModel::~SortableGridDataModel()
     245             :     {
     246           8 :         if ( !rBHelper.bDisposed )
     247             :         {
     248           0 :             acquire();
     249           0 :             dispose();
     250             :         }
     251          16 :     }
     252             : 
     253             : 
     254         230 :     Any SAL_CALL SortableGridDataModel::queryInterface( const Type& aType ) throw (RuntimeException, std::exception)
     255             :     {
     256         230 :         Any aReturn( SortableGridDataModel_Base::queryInterface( aType ) );
     257         230 :         if ( !aReturn.hasValue() )
     258          44 :             aReturn = SortableGridDataModel_PrivateBase::queryInterface( aType );
     259         230 :         return aReturn;
     260             :     }
     261             : 
     262             : 
     263         764 :     void SAL_CALL SortableGridDataModel::acquire(  ) throw ()
     264             :     {
     265         764 :         SortableGridDataModel_Base::acquire();
     266         764 :     }
     267             : 
     268             : 
     269         754 :     void SAL_CALL SortableGridDataModel::release(  ) throw ()
     270             :     {
     271         754 :         SortableGridDataModel_Base::release();
     272         754 :     }
     273             : 
     274             : 
     275           0 :     Sequence< Type > SAL_CALL SortableGridDataModel::getTypes(  ) throw (RuntimeException, std::exception)
     276             :     {
     277           0 :         return SortableGridDataModel_Base::getTypes();
     278             :         // don't expose the types got via SortableGridDataModel_PrivateBase - they're private, after all
     279             :     }
     280             : 
     281             : 
     282           0 :     Sequence< ::sal_Int8 > SAL_CALL SortableGridDataModel::getImplementationId(  ) throw (RuntimeException, std::exception)
     283             :     {
     284           0 :         return css::uno::Sequence<sal_Int8>();
     285             :     }
     286             : 
     287             : 
     288             :     namespace
     289             :     {
     290          16 :         Reference< XCollator > lcl_loadDefaultCollator_throw( const Reference<XComponentContext> & rxContext )
     291             :         {
     292          16 :             Reference< XCollator > const xCollator = Collator::create( rxContext );
     293          16 :             xCollator->loadDefaultCollator( Application::GetSettings().GetLanguageTag().getLocale(), 0 );
     294          16 :             return xCollator;
     295             :         }
     296             :     }
     297             : 
     298             : 
     299          16 :     void SAL_CALL SortableGridDataModel::initialize( const Sequence< Any >& i_arguments ) throw (Exception, RuntimeException, std::exception)
     300             :     {
     301          16 :         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
     302             : 
     303          16 :         if ( m_delegator.is() )
     304           0 :             throw AlreadyInitializedException( OUString(), *this );
     305             : 
     306          32 :         Reference< XMutableGridDataModel > xDelegator;
     307          32 :         Reference< XCollator > xCollator;
     308          16 :         switch ( i_arguments.getLength() )
     309             :         {
     310             :         case 1: // SortableGridDataModel.create( XMutableGridDataModel )
     311          16 :             xDelegator.set( i_arguments[0], UNO_QUERY );
     312          16 :             xCollator = lcl_loadDefaultCollator_throw( m_xContext );
     313          16 :             break;
     314             : 
     315             :         case 2: // SortableGridDataModel.createWithCollator( XMutableGridDataModel, XCollator )
     316           0 :             xDelegator.set( i_arguments[0], UNO_QUERY );
     317           0 :             xCollator.set( i_arguments[1], UNO_QUERY );
     318           0 :             if ( !xCollator.is() )
     319           0 :                 throw IllegalArgumentException( OUString(), *this, 2 );
     320           0 :             break;
     321             :         }
     322          16 :         if ( !xDelegator.is() )
     323           0 :             throw IllegalArgumentException( OUString(), *this, 1 );
     324             : 
     325          16 :         m_delegator = xDelegator;
     326          16 :         m_collator = xCollator;
     327             : 
     328          16 :         m_delegator->addGridDataListener( this );
     329             : 
     330          32 :         m_isInitialized = true;
     331          16 :     }
     332             : 
     333             : 
     334          44 :     GridDataEvent SortableGridDataModel::impl_createPublicEvent( GridDataEvent const & i_originalEvent ) const
     335             :     {
     336          44 :         GridDataEvent aEvent( i_originalEvent );
     337          44 :         aEvent.Source = *const_cast< SortableGridDataModel* >( this );
     338          44 :         aEvent.FirstRow = impl_getPublicRowIndex_nothrow( aEvent.FirstRow );
     339          44 :         aEvent.LastRow = impl_getPublicRowIndex_nothrow( aEvent.LastRow );
     340          44 :         return aEvent;
     341             :     }
     342             : 
     343             : 
     344          56 :     void SortableGridDataModel::impl_broadcast( void ( SAL_CALL XGridDataListener::*i_listenerMethod )( const GridDataEvent & ),
     345             :             GridDataEvent const & i_publicEvent, MethodGuard& i_instanceLock )
     346             :     {
     347          56 :         ::cppu::OInterfaceContainerHelper* pListeners = rBHelper.getContainer( cppu::UnoType<XGridDataListener>::get() );
     348          56 :         if ( pListeners == NULL )
     349          72 :             return;
     350             : 
     351          40 :         i_instanceLock.clear();
     352          40 :         pListeners->notifyEach( i_listenerMethod, i_publicEvent );
     353             :     }
     354             : 
     355             : 
     356          20 :     void SAL_CALL SortableGridDataModel::rowsInserted( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
     357             :     {
     358          20 :         MethodGuard aGuard( *this, rBHelper );
     359             : 
     360          20 :         if ( impl_isSorted_nothrow() )
     361             :         {
     362             :             // no infrastructure is in place currently to sort the new row to its proper location,
     363             :             // so we remove the sorting here.
     364           0 :             impl_removeColumnSort( aGuard );
     365           0 :             aGuard.reset();
     366             :         }
     367             : 
     368          40 :         GridDataEvent const aEvent( impl_createPublicEvent( i_event ) );
     369          40 :         impl_broadcast( &XGridDataListener::rowsInserted, aEvent, aGuard );
     370          20 :     }
     371             : 
     372             : 
     373             :     namespace
     374             :     {
     375           0 :         void lcl_decrementValuesGreaterThan( ::std::vector< ::sal_Int32 > & io_indexMap, sal_Int32 const i_threshold )
     376             :         {
     377           0 :             for (   ::std::vector< ::sal_Int32 >::iterator loop = io_indexMap.begin();
     378           0 :                     loop != io_indexMap.end();
     379             :                     ++loop
     380             :                 )
     381             :             {
     382           0 :                 if ( *loop >= i_threshold )
     383           0 :                     --*loop;
     384             :             }
     385           0 :         }
     386             :     }
     387             : 
     388             : 
     389           0 :     void SortableGridDataModel::impl_rebuildIndexesAndNotify( MethodGuard& i_instanceLock )
     390             :     {
     391             :         OSL_PRECOND( impl_isSorted_nothrow(), "SortableGridDataModel::impl_rebuildIndexesAndNotify: illegal call!" );
     392             : 
     393             :         // clear the indexes
     394           0 :         lcl_clear( m_publicToPrivateRowIndex );
     395           0 :         lcl_clear( m_privateToPublicRowIndex );
     396             : 
     397             :         // rebuild the index
     398           0 :         if ( !impl_reIndex_nothrow( m_currentSortColumn, m_sortAscending ) )
     399             :         {
     400           0 :             impl_removeColumnSort( i_instanceLock );
     401           0 :             return;
     402             :         }
     403             : 
     404             :         // broadcast an artificial event, saying that all rows have been removed
     405           0 :         GridDataEvent const aRemovalEvent( *this, -1, -1, -1, -1 );
     406           0 :         impl_broadcast( &XGridDataListener::rowsRemoved, aRemovalEvent, i_instanceLock );
     407           0 :         i_instanceLock.reset();
     408             : 
     409             :         // broadcast an artificial event, saying that n rows have been added
     410           0 :         GridDataEvent const aAdditionEvent( *this, -1, -1, 0, m_delegator->getRowCount() - 1 );
     411           0 :         impl_broadcast( &XGridDataListener::rowsInserted, aAdditionEvent, i_instanceLock );
     412             :     }
     413             : 
     414             : 
     415          14 :     void SAL_CALL SortableGridDataModel::rowsRemoved( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
     416             :     {
     417          14 :         MethodGuard aGuard( *this, rBHelper );
     418             : 
     419             :         // if the data is not sorted, broadcast the event unchanged
     420          14 :         if ( !impl_isSorted_nothrow() )
     421             :         {
     422          14 :             GridDataEvent const aEvent( impl_createPublicEvent( i_event ) );
     423          14 :             impl_broadcast( &XGridDataListener::rowsRemoved, aEvent, aGuard );
     424          14 :             return;
     425             :         }
     426             : 
     427             :         // if all rows have been removed, also simply multiplex to own listeners
     428           0 :         if ( i_event.FirstRow < 0 )
     429             :         {
     430           0 :             lcl_clear( m_publicToPrivateRowIndex );
     431           0 :             lcl_clear( m_privateToPublicRowIndex );
     432           0 :             GridDataEvent aEvent( i_event );
     433           0 :             aEvent.Source = *this;
     434           0 :             impl_broadcast( &XGridDataListener::rowsRemoved, aEvent, aGuard );
     435           0 :             return;
     436             :         }
     437             : 
     438           0 :         bool needReIndex = false;
     439           0 :         if ( i_event.FirstRow != i_event.LastRow )
     440             :         {
     441             :             OSL_ENSURE( false, "SortableGridDataModel::rowsRemoved: missing implementation - removal of multiple rows!" );
     442           0 :             needReIndex = true;
     443             :         }
     444           0 :         else if ( size_t( i_event.FirstRow ) >= m_privateToPublicRowIndex.size() )
     445             :         {
     446             :             OSL_ENSURE( false, "SortableGridDataModel::rowsRemoved: inconsistent/wrong data!" );
     447           0 :             needReIndex = true;
     448             :         }
     449             : 
     450           0 :         if ( needReIndex )
     451             :         {
     452           0 :             impl_rebuildIndexesAndNotify( aGuard );
     453           0 :             return;
     454             :         }
     455             : 
     456             :         // build public event version
     457           0 :         GridDataEvent const aEvent( impl_createPublicEvent( i_event ) );
     458             : 
     459             :         // remove the entries from the index maps
     460           0 :         sal_Int32 const privateIndex = i_event.FirstRow;
     461           0 :         sal_Int32 const publicIndex = aEvent.FirstRow;
     462             : 
     463           0 :         m_publicToPrivateRowIndex.erase( m_publicToPrivateRowIndex.begin() + publicIndex );
     464           0 :         m_privateToPublicRowIndex.erase( m_privateToPublicRowIndex.begin() + privateIndex );
     465             : 
     466             :         // adjust remaining entries in the index maps
     467           0 :         lcl_decrementValuesGreaterThan( m_publicToPrivateRowIndex, privateIndex );
     468           0 :         lcl_decrementValuesGreaterThan( m_privateToPublicRowIndex, publicIndex );
     469             : 
     470             :         // broadcast the event
     471           0 :         impl_broadcast( &XGridDataListener::rowsRemoved, aEvent, aGuard );
     472             :     }
     473             : 
     474             : 
     475           8 :     void SAL_CALL SortableGridDataModel::dataChanged( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
     476             :     {
     477           8 :         MethodGuard aGuard( *this, rBHelper );
     478             : 
     479          16 :         GridDataEvent const aEvent( impl_createPublicEvent( i_event ) );
     480          16 :         impl_broadcast( &XGridDataListener::dataChanged, aEvent, aGuard );
     481           8 :     }
     482             : 
     483             : 
     484           2 :     void SAL_CALL SortableGridDataModel::rowHeadingChanged( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
     485             :     {
     486           2 :         MethodGuard aGuard( *this, rBHelper );
     487             : 
     488           4 :         GridDataEvent const aEvent( impl_createPublicEvent( i_event ) );
     489           4 :         impl_broadcast( &XGridDataListener::rowHeadingChanged, aEvent, aGuard );
     490           2 :     }
     491             : 
     492             : 
     493           0 :     void SAL_CALL SortableGridDataModel::disposing( const EventObject& i_event ) throw (RuntimeException, std::exception)
     494             :     {
     495             :         // not interested in
     496             :         OSL_UNUSED( i_event );
     497           0 :     }
     498             : 
     499             : 
     500             :     namespace
     501             :     {
     502             :         class CellDataLessComparison : public ::std::binary_function< sal_Int32, sal_Int32, bool >
     503             :         {
     504             :         public:
     505          12 :             CellDataLessComparison(
     506             :                 ::std::vector< Any > const & i_data,
     507             :                 ::comphelper::IKeyPredicateLess& i_predicate,
     508             :                 bool const i_sortAscending
     509             :             )
     510             :                 :m_data( i_data )
     511             :                 ,m_predicate( i_predicate )
     512          12 :                 ,m_sortAscending( i_sortAscending )
     513             :             {
     514          12 :             }
     515             : 
     516         412 :             bool operator()( sal_Int32 const i_lhs, sal_Int32 const i_rhs ) const
     517             :             {
     518         412 :                 Any const & lhs = m_data[ i_lhs ];
     519         412 :                 Any const & rhs = m_data[ i_rhs ];
     520             :                 // <VOID/> is less than everything else
     521         412 :                 if ( !lhs.hasValue() )
     522           0 :                     return m_sortAscending;
     523         412 :                 if ( !rhs.hasValue() )
     524           0 :                     return !m_sortAscending;
     525             : 
     526             :                 // actually compare
     527         412 :                 if ( m_sortAscending )
     528         212 :                     return m_predicate.isLess( lhs, rhs );
     529             :                 else
     530         200 :                     return m_predicate.isLess( rhs, lhs );
     531             :             }
     532             : 
     533             :         private:
     534             :             ::std::vector< Any > const &            m_data;
     535             :             ::comphelper::IKeyPredicateLess const & m_predicate;
     536             :             bool const                          m_sortAscending;
     537             :         };
     538             :     }
     539             : 
     540             : 
     541          12 :     bool SortableGridDataModel::impl_reIndex_nothrow( ::sal_Int32 const i_columnIndex, bool const i_sortAscending )
     542             :     {
     543          12 :         ::sal_Int32 const rowCount( getRowCount() );
     544          12 :         ::std::vector< ::sal_Int32 > aPublicToPrivate( rowCount );
     545             : 
     546             :         try
     547             :         {
     548             :             // build an unsorted translation table, and retrieve the unsorted data
     549          12 :             ::std::vector< Any > aColumnData( rowCount );
     550          24 :             Type dataType;
     551         132 :             for ( ::sal_Int32 rowIndex = 0; rowIndex < rowCount; ++rowIndex )
     552             :             {
     553         120 :                 aColumnData[ rowIndex ] = m_delegator->getCellData( i_columnIndex, rowIndex );
     554         120 :                 aPublicToPrivate[ rowIndex ] = rowIndex;
     555             : 
     556             :                 // determine the data types we assume for the complete column
     557         120 :                 if ( ( dataType.getTypeClass() == TypeClass_VOID ) && aColumnData[ rowIndex ].hasValue() )
     558          12 :                     dataType = aColumnData[ rowIndex ].getValueType();
     559             :             }
     560             : 
     561             :             // get predicate object
     562          24 :             ::std::unique_ptr< ::comphelper::IKeyPredicateLess > const pPredicate( ::comphelper::getStandardLessPredicate( dataType, m_collator ) );
     563          12 :             ENSURE_OR_RETURN_FALSE( pPredicate.get(), "SortableGridDataModel::impl_reIndex_nothrow: no sortable data found!" );
     564             : 
     565             :             // then sort
     566          12 :             CellDataLessComparison const aComparator( aColumnData, *pPredicate, i_sortAscending );
     567          24 :             ::std::sort( aPublicToPrivate.begin(), aPublicToPrivate.end(), aComparator );
     568             :         }
     569           0 :         catch( const Exception& )
     570             :         {
     571             :             DBG_UNHANDLED_EXCEPTION();
     572           0 :             return false;
     573             :         }
     574             : 
     575             :         // also build the "private to public" mapping
     576          24 :         ::std::vector< sal_Int32 > aPrivateToPublic( aPublicToPrivate.size() );
     577         132 :         for ( size_t i=0; i<aPublicToPrivate.size(); ++i )
     578         120 :             aPrivateToPublic[ aPublicToPrivate[i] ] = i;
     579             : 
     580          12 :         m_publicToPrivateRowIndex.swap( aPublicToPrivate );
     581          12 :         m_privateToPublicRowIndex.swap( aPrivateToPublic );
     582             : 
     583          24 :         return true;
     584             :     }
     585             : 
     586             : 
     587          12 :     void SAL_CALL SortableGridDataModel::sortByColumn( ::sal_Int32 i_columnIndex, sal_Bool i_sortAscending ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     588             :     {
     589          12 :         MethodGuard aGuard( *this, rBHelper );
     590             : 
     591          12 :         if ( ( i_columnIndex < 0 ) || ( i_columnIndex >= getColumnCount() ) )
     592           0 :             throw IndexOutOfBoundsException( OUString(), *this );
     593             : 
     594          12 :         if ( !impl_reIndex_nothrow( i_columnIndex, i_sortAscending ) )
     595          12 :             return;
     596             : 
     597          12 :         m_currentSortColumn = i_columnIndex;
     598          12 :         m_sortAscending = i_sortAscending;
     599             : 
     600             :         impl_broadcast(
     601             :             &XGridDataListener::dataChanged,
     602             :             GridDataEvent( *this, -1, -1, -1, -1 ),
     603             :             aGuard
     604          12 :         );
     605             :     }
     606             : 
     607             : 
     608           0 :     void SortableGridDataModel::impl_removeColumnSort_noBroadcast()
     609             :     {
     610           0 :         lcl_clear( m_publicToPrivateRowIndex );
     611           0 :         lcl_clear( m_privateToPublicRowIndex );
     612             : 
     613           0 :         m_currentSortColumn = -1;
     614           0 :         m_sortAscending = true;
     615           0 :     }
     616             : 
     617             : 
     618           0 :     void SortableGridDataModel::impl_removeColumnSort( MethodGuard& i_instanceLock )
     619             :     {
     620           0 :         impl_removeColumnSort_noBroadcast();
     621             :         impl_broadcast(
     622             :             &XGridDataListener::dataChanged,
     623             :             GridDataEvent( *this, -1, -1, -1, -1 ),
     624             :             i_instanceLock
     625           0 :         );
     626           0 :     }
     627             : 
     628             : 
     629           0 :     void SAL_CALL SortableGridDataModel::removeColumnSort(  ) throw (RuntimeException, std::exception)
     630             :     {
     631           0 :         MethodGuard aGuard( *this, rBHelper );
     632           0 :         impl_removeColumnSort( aGuard );
     633           0 :     }
     634             : 
     635             : 
     636          12 :     css::beans::Pair< ::sal_Int32, sal_Bool > SAL_CALL SortableGridDataModel::getCurrentSortOrder(  ) throw (RuntimeException, std::exception)
     637             :     {
     638          12 :         MethodGuard aGuard( *this, rBHelper );
     639             : 
     640          12 :         return css::beans::Pair< ::sal_Int32, sal_Bool >( m_currentSortColumn, m_sortAscending );
     641             :     }
     642             : 
     643             : 
     644           8 :     void SAL_CALL SortableGridDataModel::addRow( const Any& i_heading, const Sequence< Any >& i_data ) throw (RuntimeException, std::exception)
     645             :     {
     646           8 :         MethodGuard aGuard( *this, rBHelper );
     647             : 
     648          16 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     649           8 :         aGuard.clear();
     650          16 :         delegator->addRow( i_heading, i_data );
     651           8 :     }
     652             : 
     653             : 
     654          10 :     void SAL_CALL SortableGridDataModel::addRows( const Sequence< Any >& i_headings, const Sequence< Sequence< Any > >& i_data ) throw (IllegalArgumentException, RuntimeException, std::exception)
     655             :     {
     656          10 :         MethodGuard aGuard( *this, rBHelper );
     657             : 
     658          20 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     659          10 :         aGuard.clear();
     660          20 :         delegator->addRows( i_headings, i_data );
     661           8 :     }
     662             : 
     663             : 
     664           6 :     void SAL_CALL SortableGridDataModel::insertRow( ::sal_Int32 i_index, const Any& i_heading, const Sequence< Any >& i_data ) throw (RuntimeException, IndexOutOfBoundsException, std::exception)
     665             :     {
     666           6 :         MethodGuard aGuard( *this, rBHelper );
     667             : 
     668           6 :         ::sal_Int32 const rowIndex = i_index == getRowCount() ? i_index : impl_getPrivateRowIndex_throw( i_index );
     669             :             // note that |RowCount| is a valid index in this method, but not for impl_getPrivateRowIndex_throw
     670             : 
     671           4 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     672           2 :         aGuard.clear();
     673           8 :         delegator->insertRow( rowIndex, i_heading, i_data );
     674           2 :     }
     675             : 
     676             : 
     677           8 :     void SAL_CALL SortableGridDataModel::insertRows( ::sal_Int32 i_index, const Sequence< Any>& i_headings, const Sequence< Sequence< Any > >& i_data ) throw (IllegalArgumentException, IndexOutOfBoundsException, RuntimeException, std::exception)
     678             :     {
     679           8 :         MethodGuard aGuard( *this, rBHelper );
     680             : 
     681           8 :         ::sal_Int32 const rowIndex = i_index == getRowCount() ? i_index : impl_getPrivateRowIndex_throw( i_index );
     682             :             // note that |RowCount| is a valid index in this method, but not for impl_getPrivateRowIndex_throw
     683             : 
     684           8 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     685           4 :         aGuard.clear();
     686          12 :         delegator->insertRows( rowIndex, i_headings, i_data );
     687           2 :     }
     688             : 
     689             : 
     690          16 :     void SAL_CALL SortableGridDataModel::removeRow( ::sal_Int32 i_rowIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     691             :     {
     692          16 :         MethodGuard aGuard( *this, rBHelper );
     693             : 
     694          16 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     695             : 
     696          24 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     697          12 :         aGuard.clear();
     698          28 :         delegator->removeRow( rowIndex );
     699          12 :     }
     700             : 
     701             : 
     702           2 :     void SAL_CALL SortableGridDataModel::removeAllRows(  ) throw (RuntimeException, std::exception)
     703             :     {
     704           2 :         MethodGuard aGuard( *this, rBHelper );
     705             : 
     706           4 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     707           2 :         aGuard.clear();
     708           4 :         delegator->removeAllRows();
     709           2 :     }
     710             : 
     711             : 
     712          12 :     void SAL_CALL SortableGridDataModel::updateCellData( ::sal_Int32 i_columnIndex, ::sal_Int32 i_rowIndex, const Any& i_value ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     713             :     {
     714          12 :         MethodGuard aGuard( *this, rBHelper );
     715             : 
     716          12 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     717             : 
     718          16 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     719           8 :         aGuard.clear();
     720          20 :         delegator->updateCellData( i_columnIndex, rowIndex, i_value );
     721           6 :     }
     722             : 
     723             : 
     724           8 :     void SAL_CALL SortableGridDataModel::updateRowData( const Sequence< ::sal_Int32 >& i_columnIndexes, ::sal_Int32 i_rowIndex, const Sequence< Any >& i_values ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException, std::exception)
     725             :     {
     726           8 :         MethodGuard aGuard( *this, rBHelper );
     727             : 
     728           8 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     729             : 
     730          12 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     731           6 :         aGuard.clear();
     732          14 :         delegator->updateRowData( i_columnIndexes, rowIndex, i_values );
     733           2 :     }
     734             : 
     735             : 
     736           4 :     void SAL_CALL SortableGridDataModel::updateRowHeading( ::sal_Int32 i_rowIndex, const Any& i_heading ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     737             :     {
     738           4 :         MethodGuard aGuard( *this, rBHelper );
     739             : 
     740           4 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     741             : 
     742           4 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     743           2 :         aGuard.clear();
     744           6 :         delegator->updateRowHeading( rowIndex, i_heading );
     745           2 :     }
     746             : 
     747             : 
     748           0 :     void SAL_CALL SortableGridDataModel::updateCellToolTip( ::sal_Int32 i_columnIndex, ::sal_Int32 i_rowIndex, const Any& i_value ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     749             :     {
     750           0 :         MethodGuard aGuard( *this, rBHelper );
     751             : 
     752           0 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     753             : 
     754           0 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     755           0 :         aGuard.clear();
     756           0 :         delegator->updateCellToolTip( i_columnIndex, rowIndex, i_value );
     757           0 :     }
     758             : 
     759             : 
     760           0 :     void SAL_CALL SortableGridDataModel::updateRowToolTip( ::sal_Int32 i_rowIndex, const Any& i_value ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     761             :     {
     762           0 :         MethodGuard aGuard( *this, rBHelper );
     763             : 
     764           0 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     765             : 
     766           0 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     767           0 :         aGuard.clear();
     768           0 :         delegator->updateRowToolTip( rowIndex, i_value );
     769           0 :     }
     770             : 
     771             : 
     772           4 :     void SAL_CALL SortableGridDataModel::addGridDataListener( const Reference< XGridDataListener >& i_listener ) throw (RuntimeException, std::exception)
     773             :     {
     774           4 :         rBHelper.addListener( cppu::UnoType<XGridDataListener>::get(), i_listener );
     775           4 :     }
     776             : 
     777             : 
     778           4 :     void SAL_CALL SortableGridDataModel::removeGridDataListener( const Reference< XGridDataListener >& i_listener ) throw (RuntimeException, std::exception)
     779             :     {
     780           4 :         rBHelper.removeListener( cppu::UnoType<XGridDataListener>::get(), i_listener );
     781           4 :     }
     782             : 
     783             : 
     784          82 :     ::sal_Int32 SAL_CALL SortableGridDataModel::getRowCount() throw (RuntimeException, std::exception)
     785             :     {
     786          82 :         MethodGuard aGuard( *this, rBHelper );
     787             : 
     788         164 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     789          82 :         aGuard.clear();
     790         164 :         return delegator->getRowCount();
     791             :     }
     792             : 
     793             : 
     794          38 :     ::sal_Int32 SAL_CALL SortableGridDataModel::getColumnCount() throw (RuntimeException, std::exception)
     795             :     {
     796          38 :         MethodGuard aGuard( *this, rBHelper );
     797             : 
     798          76 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     799          38 :         aGuard.clear();
     800          76 :         return delegator->getColumnCount();
     801             :     }
     802             : 
     803             : 
     804         766 :     Any SAL_CALL SortableGridDataModel::getCellData( ::sal_Int32 i_columnIndex, ::sal_Int32 i_rowIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     805             :     {
     806         766 :         MethodGuard aGuard( *this, rBHelper );
     807             : 
     808         766 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     809             : 
     810        1532 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     811         766 :         aGuard.clear();
     812        1532 :         return delegator->getCellData( i_columnIndex, rowIndex );
     813             :     }
     814             : 
     815             : 
     816           0 :     Any SAL_CALL SortableGridDataModel::getCellToolTip( ::sal_Int32 i_columnIndex, ::sal_Int32 i_rowIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     817             :     {
     818           0 :         MethodGuard aGuard( *this, rBHelper );
     819             : 
     820           0 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     821             : 
     822           0 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     823           0 :         aGuard.clear();
     824           0 :         return delegator->getCellToolTip( i_columnIndex, rowIndex );
     825             :     }
     826             : 
     827             : 
     828         156 :     Any SAL_CALL SortableGridDataModel::getRowHeading( ::sal_Int32 i_rowIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     829             :     {
     830         156 :         MethodGuard aGuard( *this, rBHelper );
     831             : 
     832         156 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     833             : 
     834         312 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     835         156 :         aGuard.clear();
     836         312 :         return delegator->getRowHeading( rowIndex );
     837             :     }
     838             : 
     839             : 
     840          38 :     Sequence< Any > SAL_CALL SortableGridDataModel::getRowData( ::sal_Int32 i_rowIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     841             :     {
     842          38 :         MethodGuard aGuard( *this, rBHelper );
     843             : 
     844          38 :         ::sal_Int32 const rowIndex = impl_getPrivateRowIndex_throw( i_rowIndex );
     845             : 
     846          76 :         Reference< XMutableGridDataModel > const delegator( m_delegator );
     847          38 :         aGuard.clear();
     848          76 :         return delegator->getRowData( rowIndex );
     849             :     }
     850             : 
     851             : 
     852           8 :     void SAL_CALL SortableGridDataModel::disposing()
     853             :     {
     854           8 :         m_currentSortColumn = -1;
     855             : 
     856           8 :         Reference< XComponent > const delegatorComponent( m_delegator.get() );
     857           8 :         m_delegator->removeGridDataListener( this );
     858           8 :         m_delegator.clear();
     859           8 :         delegatorComponent->dispose();
     860             : 
     861          16 :         Reference< XComponent > const collatorComponent( m_collator, UNO_QUERY );
     862           8 :         m_collator.clear();
     863           8 :         if ( collatorComponent.is() )
     864           0 :             collatorComponent->dispose();
     865             : 
     866           8 :         lcl_clear( m_publicToPrivateRowIndex );
     867          16 :         lcl_clear( m_privateToPublicRowIndex );
     868           8 :     }
     869             : 
     870             : 
     871           2 :     Reference< css::util::XCloneable > SAL_CALL SortableGridDataModel::createClone(  ) throw (RuntimeException, std::exception)
     872             :     {
     873           2 :         MethodGuard aGuard( *this, rBHelper );
     874             : 
     875           2 :         return new SortableGridDataModel( *this );
     876             :     }
     877             : 
     878             : 
     879           0 :     OUString SAL_CALL SortableGridDataModel::getImplementationName(  ) throw (RuntimeException, std::exception)
     880             :     {
     881           0 :         return OUString( "org.openoffice.comp.toolkit.SortableGridDataModel" );
     882             :     }
     883             : 
     884           0 :     sal_Bool SAL_CALL SortableGridDataModel::supportsService( const OUString& i_serviceName ) throw (RuntimeException, std::exception)
     885             :     {
     886           0 :         return cppu::supportsService(this, i_serviceName);
     887             :     }
     888             : 
     889           0 :     Sequence< OUString > SAL_CALL SortableGridDataModel::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
     890             :     {
     891           0 :         Sequence< OUString > aServiceNames(1);
     892           0 :         aServiceNames[0] = OUString("com.sun.star.awt.grid.SortableGridDataModel");
     893           0 :         return aServiceNames;
     894             :     }
     895             : 
     896             : 
     897        1014 :     ::sal_Int32 SortableGridDataModel::impl_getPrivateRowIndex_throw( ::sal_Int32 const i_publicRowIndex ) const
     898             :     {
     899        1014 :         if ( ( i_publicRowIndex < 0 ) || ( i_publicRowIndex >= m_delegator->getRowCount() ) )
     900          20 :             throw IndexOutOfBoundsException( OUString(), *const_cast< SortableGridDataModel* >( this ) );
     901             : 
     902         994 :         if ( !impl_isSorted_nothrow() )
     903             :             // no need to translate anything
     904         346 :             return i_publicRowIndex;
     905             : 
     906         648 :         ENSURE_OR_RETURN( size_t( i_publicRowIndex ) < m_publicToPrivateRowIndex.size(),
     907             :             "SortableGridDataModel::impl_getPrivateRowIndex_throw: inconsistency!", i_publicRowIndex );
     908             :                 // obviously the translation table contains too few elements - it should have exactly |getRowCount()|
     909             :                 // elements
     910             : 
     911         648 :         return m_publicToPrivateRowIndex[ i_publicRowIndex ];
     912             :     }
     913             : 
     914             : 
     915          88 :     ::sal_Int32 SortableGridDataModel::impl_getPublicRowIndex_nothrow( ::sal_Int32 const i_privateRowIndex ) const
     916             :     {
     917          88 :         if ( !impl_isSorted_nothrow() )
     918             :             // no need to translate anything
     919          88 :             return i_privateRowIndex;
     920             : 
     921           0 :         if ( i_privateRowIndex < 0 )
     922           0 :             return i_privateRowIndex;
     923             : 
     924           0 :         ENSURE_OR_RETURN( size_t( i_privateRowIndex ) < m_privateToPublicRowIndex.size(),
     925             :             "SortableGridDataModel::impl_getPublicRowIndex_nothrow: invalid index!", i_privateRowIndex );
     926             : 
     927           0 :         return m_privateToPublicRowIndex[ i_privateRowIndex ];
     928             :     }
     929             : 
     930             : }
     931             : 
     932             : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
     933          16 : org_openoffice_comp_toolkit_SortableGridDataModel_get_implementation(
     934             :     css::uno::XComponentContext *context,
     935             :     css::uno::Sequence<css::uno::Any> const &)
     936             : {
     937          16 :     return cppu::acquire(new SortableGridDataModel(context));
     938        1227 : }
     939             : 
     940             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10