toolkit/source/controls/grid/defaultgridcolumnmodel.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
  21 #include "defaultgridcolumnmodel.hxx"
  22 #include "gridcolumn.hxx"
  23
  24 #include <com/sun/star/awt/XVclWindowPeer.hpp>
  25
  26 #include <comphelper/sequence.hxx>
  27 #include <comphelper/componentguard.hxx>
  28 #include <comphelper/processfactory.hxx>
  29 #include <toolkit/helper/servicenames.hxx>
  30 #include <rtl/ustrbuf.hxx>
  31 #include <tools/diagnose_ex.h>
  32
  33 //......................................................................................................................
  34 namespace toolkit
  35 //......................................................................................................................
  36 {
  37     using ::com::sun::star::uno::Reference;
  38     using ::com::sun::star::uno::XComponentContext;
  39     using ::com::sun::star::lang::XMultiServiceFactory;
  40     using ::com::sun::star::uno::RuntimeException;
  41     using ::com::sun::star::uno::Sequence;
  42     using ::com::sun::star::uno::UNO_QUERY_THROW;
  43     using ::com::sun::star::uno::UNO_QUERY;
  44     using ::com::sun::star::awt::grid::XGridColumn;
  45     using ::com::sun::star::uno::XInterface;
  46     using ::com::sun::star::lang::XComponent;
  47     using ::com::sun::star::lang::EventObject;
  48     using ::com::sun::star::container::XContainerListener;
  49     using ::com::sun::star::container::ContainerEvent;
  50     using ::com::sun::star::uno::Exception;
  51     using ::com::sun::star::lang::IndexOutOfBoundsException;
  52     using ::com::sun::star::util::XCloneable;
  53     using ::com::sun::star::lang::IllegalArgumentException;
  54
  55     //==================================================================================================================
  56     //= DefaultGridColumnModel
  57     //==================================================================================================================
  58     //------------------------------------------------------------------------------------------------------------------
  59     DefaultGridColumnModel::DefaultGridColumnModel( const Reference< XComponentContext >& i_context )
  60         :DefaultGridColumnModel_Base( m_aMutex )
  61         ,m_aContext( i_context )
  62         ,m_aContainerListeners( m_aMutex )
  63         ,m_aColumns()
  64     {
  65     }
  66
  67     //------------------------------------------------------------------------------------------------------------------
  68     DefaultGridColumnModel::DefaultGridColumnModel( DefaultGridColumnModel const & i_copySource )
  69         :cppu::BaseMutex()
  70         ,DefaultGridColumnModel_Base( m_aMutex )
  71         ,m_aContext( i_copySource.m_aContext )
  72         ,m_aContainerListeners( m_aMutex )
  73         ,m_aColumns()
  74     {
  75         Columns aColumns;
  76         aColumns.reserve( i_copySource.m_aColumns.size() );
  77         try
  78         {
  79             for (   Columns::const_iterator col = i_copySource.m_aColumns.begin();
  80                     col != i_copySource.m_aColumns.end();
  81                     ++col
  82                 )
  83             {
  84                 Reference< XCloneable > const xCloneable( *col, UNO_QUERY_THROW );
  85                 Reference< XGridColumn > const xClone( xCloneable->createClone(), UNO_QUERY_THROW );
  86
  87                 GridColumn* const pGridColumn = GridColumn::getImplementation( xClone );
  88                 if ( pGridColumn == NULL )
  89                     throw RuntimeException( "invalid clone source implementation", *this );
  90                     // that's indeed a RuntimeException, not an IllegalArgumentException or some such:
  91                     // a DefaultGridColumnModel implementation whose columns are not GridColumn implementations
  92                     // is borked.
  93                 pGridColumn->setIndex( col - i_copySource.m_aColumns.begin() );
  94
  95                 aColumns.push_back( xClone );
  96             }
  97         }
  98         catch( const Exception& )
  99         {
 100             DBG_UNHANDLED_EXCEPTION();
 101         }
 102         if ( aColumns.size() == i_copySource.m_aColumns.size() )
 103             m_aColumns.swap( aColumns );
 104     }
 105
 106     //------------------------------------------------------------------------------------------------------------------
 107     DefaultGridColumnModel::~DefaultGridColumnModel()
 108     {
 109     }
 110
 111     //------------------------------------------------------------------------------------------------------------------
 112     ::sal_Int32 SAL_CALL DefaultGridColumnModel::getColumnCount() throw (RuntimeException)
 113     {
 114         return m_aColumns.size();
 115     }
 116
 117     //------------------------------------------------------------------------------------------------------------------
 118     Reference< XGridColumn > SAL_CALL DefaultGridColumnModel::createColumn(  ) throw (RuntimeException)
 119     {
 120         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 121         return new GridColumn();
 122     }
 123
 124     //------------------------------------------------------------------------------------------------------------------
 125     ::sal_Int32 SAL_CALL DefaultGridColumnModel::addColumn( const Reference< XGridColumn > & i_column ) throw (RuntimeException, IllegalArgumentException)
 126     {
 127         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 128
 129         GridColumn* const pGridColumn = GridColumn::getImplementation( i_column );
 130         if ( pGridColumn == NULL )
 131             throw IllegalArgumentException( "invalid column implementation", *this, 1 );
 132
 133         m_aColumns.push_back( i_column );
 134         sal_Int32 index = m_aColumns.size() - 1;
 135         pGridColumn->setIndex( index );
 136
 137         // fire insertion notifications
 138         ContainerEvent aEvent;
 139         aEvent.Source = *this;
 140         aEvent.Accessor <<= index;
 141         aEvent.Element <<= i_column;
 142
 143         aGuard.clear();
 144         m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvent );
 145
 146         return index;
 147     }
 148
 149     //------------------------------------------------------------------------------------------------------------------
 150     void SAL_CALL DefaultGridColumnModel::removeColumn( ::sal_Int32 i_columnIndex )  throw (RuntimeException, IndexOutOfBoundsException)
 151     {
 152         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 153
 154         if ( ( i_columnIndex < 0 ) || ( size_t( i_columnIndex ) >= m_aColumns.size() ) )
 155             throw IndexOutOfBoundsException( OUString(), *this );
 156
 157         Columns::iterator const pos = m_aColumns.begin() + i_columnIndex;
 158         Reference< XGridColumn > const xColumn( *pos );
 159         m_aColumns.erase( pos );
 160
 161         // update indexes of all subsequent columns
 162         sal_Int32 columnIndex( i_columnIndex );
 163         for (   Columns::iterator updatePos = m_aColumns.begin() + columnIndex;
 164                 updatePos != m_aColumns.end();
 165                 ++updatePos, ++columnIndex
 166             )
 167         {
 168             GridColumn* pColumnImpl = GridColumn::getImplementation( *updatePos );
 169             if ( !pColumnImpl )
 170             {
 171                 SAL_WARN( "toolkit.controls", "DefaultGridColumnModel::removeColumn: invalid column implementation!" );
 172                 continue;
 173             }
 174
 175             pColumnImpl->setIndex( columnIndex );
 176         }
 177
 178         // fire removal notifications
 179         ContainerEvent aEvent;
 180         aEvent.Source = *this;
 181         aEvent.Accessor <<= i_columnIndex;
 182         aEvent.Element <<= xColumn;
 183
 184         aGuard.clear();
 185         m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, aEvent );
 186
 187         // dispose the removed column
 188         try
 189         {
 190             Reference< XComponent > const xColComp( xColumn, UNO_QUERY_THROW );
 191             xColComp->dispose();
 192         }
 193         catch( const Exception& )
 194         {
 195             DBG_UNHANDLED_EXCEPTION();
 196         }
 197     }
 198
 199     //------------------------------------------------------------------------------------------------------------------
 200     Sequence< Reference< XGridColumn > > SAL_CALL DefaultGridColumnModel::getColumns() throw (RuntimeException)
 201     {
 202         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 203         return ::comphelper::containerToSequence( m_aColumns );
 204     }
 205
 206     //------------------------------------------------------------------------------------------------------------------
 207     Reference< XGridColumn > SAL_CALL DefaultGridColumnModel::getColumn(::sal_Int32 index) throw (IndexOutOfBoundsException, RuntimeException)
 208     {
 209         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 210
 211         if ( index >=0 && index < ((sal_Int32)m_aColumns.size()))
 212             return m_aColumns[index];
 213
 214         throw IndexOutOfBoundsException();
 215     }
 216
 217     //------------------------------------------------------------------------------------------------------------------
 218     void SAL_CALL DefaultGridColumnModel::setDefaultColumns(sal_Int32 rowElements) throw (RuntimeException)
 219     {
 220         ::std::vector< ContainerEvent > aRemovedColumns;
 221         ::std::vector< ContainerEvent > aInsertedColumns;
 222
 223         {
 224             ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 225
 226             // remove existing columns
 227             while ( !m_aColumns.empty() )
 228             {
 229                 const size_t lastColIndex = m_aColumns.size() - 1;
 230
 231                 ContainerEvent aEvent;
 232                 aEvent.Source = *this;
 233                 aEvent.Accessor <<= sal_Int32( lastColIndex );
 234                 aEvent.Element <<= m_aColumns[ lastColIndex ];
 235                 aRemovedColumns.push_back( aEvent );
 236
 237                 m_aColumns.erase( m_aColumns.begin() + lastColIndex );
 238             }
 239
 240             // add new columns
 241             for ( sal_Int32 i=0; i<rowElements; ++i )
 242             {
 243                 ::rtl::Reference< GridColumn > const pGridColumn = new GridColumn();
 244                 Reference< XGridColumn > const xColumn( pGridColumn.get() );
 245                 OUStringBuffer colTitle;
 246                 colTitle.appendAscii( "Column " );
 247                 colTitle.append( i + 1 );
 248                 pGridColumn->setTitle( colTitle.makeStringAndClear() );
 249                 pGridColumn->setColumnWidth( 80 /* APPFONT */ );
 250                 pGridColumn->setFlexibility( 1 );
 251                 pGridColumn->setResizeable( sal_True );
 252                 pGridColumn->setDataColumnIndex( i );
 253
 254                 ContainerEvent aEvent;
 255                 aEvent.Source = *this;
 256                 aEvent.Accessor <<= i;
 257                 aEvent.Element <<= xColumn;
 258                 aInsertedColumns.push_back( aEvent );
 259
 260                 m_aColumns.push_back( xColumn );
 261                 pGridColumn->setIndex( i );
 262             }
 263         }
 264
 265         // fire removal notifications
 266         for (   ::std::vector< ContainerEvent >::const_iterator event = aRemovedColumns.begin();
 267                 event != aRemovedColumns.end();
 268                 ++event
 269             )
 270         {
 271             m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, *event );
 272         }
 273
 274         // fire insertion notifications
 275         for (   ::std::vector< ContainerEvent >::const_iterator event = aInsertedColumns.begin();
 276                 event != aInsertedColumns.end();
 277                 ++event
 278             )
 279         {
 280             m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, *event );
 281         }
 282
 283         // dispose removed columns
 284         for (   ::std::vector< ContainerEvent >::const_iterator event = aRemovedColumns.begin();
 285                 event != aRemovedColumns.end();
 286                 ++event
 287             )
 288         {
 289             try
 290             {
 291                 const Reference< XComponent > xColComp( event->Element, UNO_QUERY_THROW );
 292                 xColComp->dispose();
 293             }
 294             catch( const Exception& )
 295             {
 296                 DBG_UNHANDLED_EXCEPTION();
 297             }
 298         }
 299     }
 300
 301     //------------------------------------------------------------------------------------------------------------------
 302     OUString SAL_CALL DefaultGridColumnModel::getImplementationName(  ) throw (RuntimeException)
 303     {
 304         return OUString( "org.openoffice.comp.toolkit.DefaultGridColumnModel" );
 305     }
 306
 307     //------------------------------------------------------------------------------------------------------------------
 308     sal_Bool SAL_CALL DefaultGridColumnModel::supportsService( const OUString& i_serviceName ) throw (RuntimeException)
 309     {
 310         const Sequence< OUString > aServiceNames( getSupportedServiceNames() );
 311         for ( sal_Int32 i=0; i<aServiceNames.getLength(); ++i )
 312             if ( aServiceNames[i] == i_serviceName )
 313                 return sal_True;
 314         return sal_False;
 315     }
 316
 317     //------------------------------------------------------------------------------------------------------------------
 318     Sequence< OUString > SAL_CALL DefaultGridColumnModel::getSupportedServiceNames(  ) throw (RuntimeException)
 319     {
 320         const OUString aServiceName( OUString::createFromAscii( szServiceName_DefaultGridColumnModel ) );
 321         const Sequence< OUString > aSeq( &aServiceName, 1 );
 322         return aSeq;
 323     }
 324
 325     //------------------------------------------------------------------------------------------------------------------
 326     void SAL_CALL DefaultGridColumnModel::addContainerListener( const Reference< XContainerListener >& i_listener ) throw (RuntimeException)
 327     {
 328         if ( i_listener.is() )
 329             m_aContainerListeners.addInterface( i_listener );
 330     }
 331
 332     //------------------------------------------------------------------------------------------------------------------
 333     void SAL_CALL DefaultGridColumnModel::removeContainerListener( const Reference< XContainerListener >& i_listener ) throw (RuntimeException)
 334     {
 335         if ( i_listener.is() )
 336             m_aContainerListeners.removeInterface( i_listener );
 337     }
 338
 339     //------------------------------------------------------------------------------------------------------------------
 340     void SAL_CALL DefaultGridColumnModel::disposing()
 341     {
 342         DefaultGridColumnModel_Base::disposing();
 343
 344         EventObject aEvent( *this );
 345         m_aContainerListeners.disposeAndClear( aEvent );
 346
 347         ::osl::MutexGuard aGuard( m_aMutex );
 348
 349         // remove, dispose and clear columns
 350         while ( !m_aColumns.empty() )
 351         {
 352             try
 353             {
 354                 const Reference< XComponent > xColComponent( m_aColumns[ 0 ], UNO_QUERY_THROW );
 355                 xColComponent->dispose();
 356             }
 357             catch( const Exception& )
 358             {
 359                 DBG_UNHANDLED_EXCEPTION();
 360             }
 361
 362             m_aColumns.erase( m_aColumns.begin() );
 363         }
 364
 365         Columns aEmpty;
 366         m_aColumns.swap( aEmpty );
 367     }
 368
 369     //------------------------------------------------------------------------------------------------------------------
 370     Reference< XCloneable > SAL_CALL DefaultGridColumnModel::createClone(  ) throw (RuntimeException)
 371     {
 372         ::comphelper::ComponentGuard aGuard( *this, rBHelper );
 373         return new DefaultGridColumnModel( *this );
 374     }
 375
 376 //......................................................................................................................
 377 }   // namespace toolkit
 378 //......................................................................................................................
 379
 380 //----------------------------------------------------------------------------------------------------------------------
 381 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL DefaultGridColumnModel_CreateInstance( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rFactory)
 382 {
 383     return ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface >( ( ::cppu::OWeakObject* ) new ::toolkit::DefaultGridColumnModel( comphelper::getComponentContext(_rFactory) ) );
 384 }
 385 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */