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