| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_toolkit.hxx" |
| |
| #include "defaultgridcolumnmodel.hxx" |
| #include "gridcolumn.hxx" |
| |
| /** === begin UNO includes === **/ |
| #include <com/sun/star/awt/XVclWindowPeer.hpp> |
| /** === end UNO includes === **/ |
| |
| #include <comphelper/sequence.hxx> |
| #include <comphelper/componentguard.hxx> |
| #include <toolkit/helper/servicenames.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <tools/diagnose_ex.h> |
| |
| //...................................................................................................................... |
| namespace toolkit |
| //...................................................................................................................... |
| { |
| /** === begin UNO using === **/ |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::lang::XMultiServiceFactory; |
| using ::com::sun::star::uno::RuntimeException; |
| using ::com::sun::star::uno::Sequence; |
| using ::com::sun::star::uno::UNO_QUERY_THROW; |
| using ::com::sun::star::uno::UNO_QUERY; |
| using ::com::sun::star::awt::grid::XGridColumn; |
| using ::com::sun::star::uno::XInterface; |
| using ::com::sun::star::lang::XMultiServiceFactory; |
| using ::com::sun::star::lang::XComponent; |
| using ::com::sun::star::lang::EventObject; |
| using ::com::sun::star::container::XContainerListener; |
| using ::com::sun::star::container::ContainerEvent; |
| using ::com::sun::star::uno::Exception; |
| using ::com::sun::star::lang::IndexOutOfBoundsException; |
| using ::com::sun::star::util::XCloneable; |
| using ::com::sun::star::lang::IllegalArgumentException; |
| /** === end UNO using === **/ |
| |
| //================================================================================================================== |
| //= DefaultGridColumnModel |
| //================================================================================================================== |
| //------------------------------------------------------------------------------------------------------------------ |
| DefaultGridColumnModel::DefaultGridColumnModel( const Reference< XMultiServiceFactory >& i_factory ) |
| :DefaultGridColumnModel_Base( m_aMutex ) |
| ,m_aContext( i_factory ) |
| ,m_aContainerListeners( m_aMutex ) |
| ,m_aColumns() |
| { |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| DefaultGridColumnModel::DefaultGridColumnModel( DefaultGridColumnModel const & i_copySource ) |
| :cppu::BaseMutex() |
| ,DefaultGridColumnModel_Base( m_aMutex ) |
| ,m_aContext( i_copySource.m_aContext ) |
| ,m_aContainerListeners( m_aMutex ) |
| ,m_aColumns() |
| { |
| Columns aColumns; |
| aColumns.reserve( i_copySource.m_aColumns.size() ); |
| try |
| { |
| for ( Columns::const_iterator col = i_copySource.m_aColumns.begin(); |
| col != i_copySource.m_aColumns.end(); |
| ++col |
| ) |
| { |
| Reference< XCloneable > const xCloneable( *col, UNO_QUERY_THROW ); |
| Reference< XGridColumn > const xClone( xCloneable->createClone(), UNO_QUERY_THROW ); |
| |
| GridColumn* const pGridColumn = GridColumn::getImplementation( xClone ); |
| if ( pGridColumn == NULL ) |
| throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "invalid clone source implementation" ) ), *this ); |
| // that's indeed a RuntimeException, not an IllegalArgumentException or some such: |
| // a DefaultGridColumnModel implementation whose columns are not GridColumn implementations |
| // is borked. |
| pGridColumn->setIndex( col - i_copySource.m_aColumns.begin() ); |
| |
| aColumns.push_back( xClone ); |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| if ( aColumns.size() == i_copySource.m_aColumns.size() ) |
| m_aColumns.swap( aColumns ); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| DefaultGridColumnModel::~DefaultGridColumnModel() |
| { |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| ::sal_Int32 SAL_CALL DefaultGridColumnModel::getColumnCount() throw (RuntimeException) |
| { |
| return m_aColumns.size(); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| Reference< XGridColumn > SAL_CALL DefaultGridColumnModel::createColumn( ) throw (RuntimeException) |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| return new GridColumn(); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| ::sal_Int32 SAL_CALL DefaultGridColumnModel::addColumn( const Reference< XGridColumn > & i_column ) throw (RuntimeException, IllegalArgumentException) |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| |
| GridColumn* const pGridColumn = GridColumn::getImplementation( i_column ); |
| if ( pGridColumn == NULL ) |
| throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "invalid column implementation" ) ), *this, 1 ); |
| |
| m_aColumns.push_back( i_column ); |
| sal_Int32 index = m_aColumns.size() - 1; |
| pGridColumn->setIndex( index ); |
| |
| // fire insertion notifications |
| ContainerEvent aEvent; |
| aEvent.Source = *this; |
| aEvent.Accessor <<= index; |
| aEvent.Element <<= i_column; |
| |
| aGuard.clear(); |
| m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvent ); |
| |
| return index; |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| void SAL_CALL DefaultGridColumnModel::removeColumn( ::sal_Int32 i_columnIndex ) throw (RuntimeException, IndexOutOfBoundsException) |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| |
| if ( ( i_columnIndex < 0 ) || ( size_t( i_columnIndex ) >= m_aColumns.size() ) ) |
| throw IndexOutOfBoundsException( ::rtl::OUString(), *this ); |
| |
| Columns::iterator const pos = m_aColumns.begin() + i_columnIndex; |
| Reference< XGridColumn > const xColumn( *pos ); |
| m_aColumns.erase( pos ); |
| |
| // update indexes of all subsequent columns |
| sal_Int32 columnIndex( i_columnIndex ); |
| for ( Columns::iterator updatePos = m_aColumns.begin() + columnIndex; |
| updatePos != m_aColumns.end(); |
| ++updatePos, ++columnIndex |
| ) |
| { |
| GridColumn* pColumnImpl = GridColumn::getImplementation( *updatePos ); |
| ENSURE_OR_CONTINUE( pColumnImpl, "DefaultGridColumnModel::removeColumn: invalid column implementation!" ); |
| pColumnImpl->setIndex( columnIndex ); |
| } |
| |
| // fire removal notifications |
| ContainerEvent aEvent; |
| aEvent.Source = *this; |
| aEvent.Accessor <<= i_columnIndex; |
| aEvent.Element <<= xColumn; |
| |
| aGuard.clear(); |
| m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, aEvent ); |
| |
| // dispose the removed column |
| try |
| { |
| Reference< XComponent > const xColComp( xColumn, UNO_QUERY_THROW ); |
| xColComp->dispose(); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| Sequence< Reference< XGridColumn > > SAL_CALL DefaultGridColumnModel::getColumns() throw (RuntimeException) |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| return ::comphelper::containerToSequence( m_aColumns ); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| Reference< XGridColumn > SAL_CALL DefaultGridColumnModel::getColumn(::sal_Int32 index) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| |
| if ( index >=0 && index < ((sal_Int32)m_aColumns.size())) |
| return m_aColumns[index]; |
| |
| throw IndexOutOfBoundsException(); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| void SAL_CALL DefaultGridColumnModel::setDefaultColumns(sal_Int32 rowElements) throw (RuntimeException) |
| { |
| ::std::vector< ContainerEvent > aRemovedColumns; |
| ::std::vector< ContainerEvent > aInsertedColumns; |
| |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| |
| // remove existing columns |
| while ( !m_aColumns.empty() ) |
| { |
| const size_t lastColIndex = m_aColumns.size() - 1; |
| |
| ContainerEvent aEvent; |
| aEvent.Source = *this; |
| aEvent.Accessor <<= sal_Int32( lastColIndex ); |
| aEvent.Element <<= m_aColumns[ lastColIndex ]; |
| aRemovedColumns.push_back( aEvent ); |
| |
| m_aColumns.erase( m_aColumns.begin() + lastColIndex ); |
| } |
| |
| // add new columns |
| for ( sal_Int32 i=0; i<rowElements; ++i ) |
| { |
| ::rtl::Reference< GridColumn > const pGridColumn = new GridColumn(); |
| Reference< XGridColumn > const xColumn( pGridColumn.get() ); |
| ::rtl::OUStringBuffer colTitle; |
| colTitle.appendAscii( "Column " ); |
| colTitle.append( i + 1 ); |
| pGridColumn->setTitle( colTitle.makeStringAndClear() ); |
| pGridColumn->setColumnWidth( 80 /* APPFONT */ ); |
| pGridColumn->setFlexibility( 1 ); |
| pGridColumn->setResizeable( sal_True ); |
| pGridColumn->setDataColumnIndex( i ); |
| |
| ContainerEvent aEvent; |
| aEvent.Source = *this; |
| aEvent.Accessor <<= i; |
| aEvent.Element <<= xColumn; |
| aInsertedColumns.push_back( aEvent ); |
| |
| m_aColumns.push_back( xColumn ); |
| pGridColumn->setIndex( i ); |
| } |
| } |
| |
| // fire removal notifications |
| for ( ::std::vector< ContainerEvent >::const_iterator event = aRemovedColumns.begin(); |
| event != aRemovedColumns.end(); |
| ++event |
| ) |
| { |
| m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, *event ); |
| } |
| |
| // fire insertion notifications |
| for ( ::std::vector< ContainerEvent >::const_iterator event = aInsertedColumns.begin(); |
| event != aInsertedColumns.end(); |
| ++event |
| ) |
| { |
| m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, *event ); |
| } |
| |
| // dispose removed columns |
| for ( ::std::vector< ContainerEvent >::const_iterator event = aRemovedColumns.begin(); |
| event != aRemovedColumns.end(); |
| ++event |
| ) |
| { |
| try |
| { |
| const Reference< XComponent > xColComp( event->Element, UNO_QUERY_THROW ); |
| xColComp->dispose(); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| ::rtl::OUString SAL_CALL DefaultGridColumnModel::getImplementationName( ) throw (RuntimeException) |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "org.openoffice.comp.toolkit.DefaultGridColumnModel" ) ); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| sal_Bool SAL_CALL DefaultGridColumnModel::supportsService( const ::rtl::OUString& i_serviceName ) throw (RuntimeException) |
| { |
| const Sequence< ::rtl::OUString > aServiceNames( getSupportedServiceNames() ); |
| for ( sal_Int32 i=0; i<aServiceNames.getLength(); ++i ) |
| if ( aServiceNames[i] == i_serviceName ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| Sequence< ::rtl::OUString > SAL_CALL DefaultGridColumnModel::getSupportedServiceNames( ) throw (RuntimeException) |
| { |
| const ::rtl::OUString aServiceName( ::rtl::OUString::createFromAscii( szServiceName_DefaultGridColumnModel ) ); |
| const Sequence< ::rtl::OUString > aSeq( &aServiceName, 1 ); |
| return aSeq; |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| void SAL_CALL DefaultGridColumnModel::addContainerListener( const Reference< XContainerListener >& i_listener ) throw (RuntimeException) |
| { |
| if ( i_listener.is() ) |
| m_aContainerListeners.addInterface( i_listener ); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| void SAL_CALL DefaultGridColumnModel::removeContainerListener( const Reference< XContainerListener >& i_listener ) throw (RuntimeException) |
| { |
| if ( i_listener.is() ) |
| m_aContainerListeners.removeInterface( i_listener ); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| void SAL_CALL DefaultGridColumnModel::disposing() |
| { |
| DefaultGridColumnModel_Base::disposing(); |
| |
| EventObject aEvent( *this ); |
| m_aContainerListeners.disposeAndClear( aEvent ); |
| |
| ::osl::MutexGuard aGuard( m_aMutex ); |
| |
| // remove, dispose and clear columns |
| while ( !m_aColumns.empty() ) |
| { |
| try |
| { |
| const Reference< XComponent > xColComponent( m_aColumns[ 0 ], UNO_QUERY_THROW ); |
| xColComponent->dispose(); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| m_aColumns.erase( m_aColumns.begin() ); |
| } |
| |
| Columns aEmpty; |
| m_aColumns.swap( aEmpty ); |
| } |
| |
| //------------------------------------------------------------------------------------------------------------------ |
| Reference< XCloneable > SAL_CALL DefaultGridColumnModel::createClone( ) throw (RuntimeException) |
| { |
| ::comphelper::ComponentGuard aGuard( *this, rBHelper ); |
| return new DefaultGridColumnModel( *this ); |
| } |
| |
| //...................................................................................................................... |
| } // namespace toolkit |
| //...................................................................................................................... |
| |
| //---------------------------------------------------------------------------------------------------------------------- |
| ::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) |
| { |
| return ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface >( ( ::cppu::OWeakObject* ) new ::toolkit::DefaultGridColumnModel( _rFactory ) ); |
| } |
