diff options
Diffstat (limited to 'svtools/source/uno/unocontroltablemodel.cxx')
-rw-r--r-- | svtools/source/uno/unocontroltablemodel.cxx | 980 |
1 files changed, 680 insertions, 300 deletions
diff --git a/svtools/source/uno/unocontroltablemodel.cxx b/svtools/source/uno/unocontroltablemodel.cxx index d239ee3c740d..933363115810 100644 --- a/svtools/source/uno/unocontroltablemodel.cxx +++ b/svtools/source/uno/unocontroltablemodel.cxx @@ -28,486 +28,866 @@ #include "precompiled_svtools.hxx" #include "unocontroltablemodel.hxx" -#include <com/sun/star/view/SelectionType.hpp> -#include "svtools/table/gridtablerenderer.hxx" +#include "unogridcolumnfacade.hxx" + #include "svtools/table/defaultinputhandler.hxx" +#include "svtools/table/gridtablerenderer.hxx" #include "svtools/table/tablecontrol.hxx" -#include <comphelper/sequence.hxx> -#include <rtl/ref.hxx> -#include <tools/debug.hxx> -#include <toolkit/helper/property.hxx> -#include <comphelper/processfactory.hxx> + +/** === begin UNO includes === **/ #include <com/sun/star/awt/grid/XGridColumn.hpp> +#include <com/sun/star/view/SelectionType.hpp> +#include <com/sun/star/awt/grid/XGridColumnListener.hpp> +#include <com/sun/star/awt/grid/XSortableGridData.hpp> +/** === end UNO includes === **/ -using ::rtl::OUString; -using namespace ::svt::table; -using namespace ::com::sun::star::uno; +#include <comphelper/stlunosequence.hxx> +#include <cppuhelper/weakref.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <vcl/svapp.hxx> +#include <vos/mutex.hxx> + +// ..................................................................................................................... +namespace svt { namespace table +{ +// ..................................................................................................................... + + /** === begin UNO using === **/ + using ::com::sun::star::uno::Reference; + 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::uno::Exception; + using ::com::sun::star::awt::grid::XGridColumnListener; + using ::com::sun::star::lang::EventObject; + using ::com::sun::star::awt::grid::GridColumnEvent; + using ::com::sun::star::awt::grid::XGridDataModel; + using ::com::sun::star::awt::grid::XGridColumnModel; + using ::com::sun::star::uno::Any; + using ::com::sun::star::style::HorizontalAlignment_LEFT; + using ::com::sun::star::style::HorizontalAlignment; + using ::com::sun::star::style::VerticalAlignment_TOP; + using ::com::sun::star::style::VerticalAlignment; + using ::com::sun::star::uno::WeakReference; + using ::com::sun::star::awt::grid::GridDataEvent; + using ::com::sun::star::awt::grid::XSortableGridData; + using ::com::sun::star::beans::Pair; + /** === end UNO using === **/ + + //================================================================================================================== + //= UnoControlTableModel_Impl + //================================================================================================================== + typedef ::std::vector< PTableModelListener > ModellListeners; + typedef ::std::vector< PColumnModel > ColumnModels; + struct UnoControlTableModel_Impl + { + ColumnModels aColumns; + bool bHasColumnHeaders; + bool bHasRowHeaders; + ScrollbarVisibility eVScrollMode; + ScrollbarVisibility eHScrollMode; + PTableRenderer pRenderer; + PTableInputHandler pInputHandler; + TableMetrics nRowHeight; + TableMetrics nColumnHeaderHeight; + TableMetrics nRowHeaderWidth; + ::boost::optional< ::Color > m_aGridLineColor; + ::boost::optional< ::Color > m_aHeaderBackgroundColor; + ::boost::optional< ::Color > m_aHeaderTextColor; + ::boost::optional< ::Color > m_aTextColor; + ::boost::optional< ::Color > m_aTextLineColor; + ::boost::optional< ::std::vector< ::Color > > m_aRowColors; + VerticalAlignment m_eVerticalAlign; + ModellListeners m_aListeners; + WeakReference< XGridDataModel > m_aDataModel; + WeakReference< XGridColumnModel > m_aColumnModel; + UnoControlTableModel_Impl() + :aColumns ( ) + ,bHasColumnHeaders ( true ) + ,bHasRowHeaders ( false ) + ,eVScrollMode ( ScrollbarShowNever ) + ,eHScrollMode ( ScrollbarShowNever ) + ,pRenderer ( ) + ,pInputHandler ( ) + ,nRowHeight ( 10 ) + ,nColumnHeaderHeight ( 10 ) + ,nRowHeaderWidth ( 10 ) + ,m_aGridLineColor ( ) + ,m_aHeaderBackgroundColor ( ) + ,m_aHeaderTextColor ( ) + ,m_aTextColor ( ) + ,m_aTextLineColor ( ) + ,m_aRowColors ( ) + ,m_eVerticalAlign ( VerticalAlignment_TOP ) + { + } + }; - //-------------------------------------------------------------------- - UnoControlTableColumn::UnoControlTableColumn(Reference<XGridColumn> m_xGridColumn) - :m_nID( 0 ) - ,m_sName() - ,m_bIsResizable( true ) - ,m_nWidth( 4 ) - ,m_nMinWidth( 0 ) - ,m_nMaxWidth( 0 ) - ,m_nPrefWidth ( 0 ) - ,m_xHorizontalAlign(com::sun::star::style::HorizontalAlignment(0)) - { - m_sName = m_xGridColumn->getTitle(); - } - //-------------------------------------------------------------------- - UnoControlTableColumn::UnoControlTableColumn() - :m_nID( 0 ) - ,m_sName() - ,m_bIsResizable( true ) - ,m_nWidth( 4 ) - ,m_nMinWidth( 0 ) - ,m_nMaxWidth( 0 ) - ,m_nPrefWidth ( 0 ) - ,m_xHorizontalAlign(com::sun::star::style::HorizontalAlignment(0)) + //================================================================================================================== + //= UnoControlTableModel + //================================================================================================================== +#ifdef DBG_UTIL + const char* UnoControlTableModel_checkInvariants( const void* _pInstance ) { + return static_cast< const UnoControlTableModel* >( _pInstance )->checkInvariants(); } - //-------------------------------------------------------------------- - ColumnID UnoControlTableColumn::getID() const + //------------------------------------------------------------------------------------------------------------------ + const char* UnoControlTableModel::checkInvariants() const { - return m_nID; - } + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + if ( !xDataModel.is() ) + return "data model anymore"; - //-------------------------------------------------------------------- - bool UnoControlTableColumn::setID( const ColumnID _nID ) - { - m_nID = _nID; - return true; - } + // TODO: more? - //-------------------------------------------------------------------- - String UnoControlTableColumn::getName() const - { - return m_sName; + return NULL; } +#endif - //-------------------------------------------------------------------- - void UnoControlTableColumn::setName( const String& _rName ) +#define DBG_CHECK_ME() \ + DBG_TESTSOLARMUTEX(); \ + DBG_CHKTHIS( UnoControlTableModel, UnoControlTableModel_checkInvariants ) + + //------------------------------------------------------------------------------------------------------------------ + DBG_NAME( UnoControlTableModel ) + UnoControlTableModel::UnoControlTableModel() + :m_pImpl( new UnoControlTableModel_Impl ) { - m_sName = _rName; + DBG_CTOR( UnoControlTableModel, UnoControlTableModel_checkInvariants ); + m_pImpl->bHasColumnHeaders = true; + m_pImpl->bHasRowHeaders = false; + m_pImpl->pRenderer.reset( new GridTableRenderer( *this ) ); + m_pImpl->pInputHandler.reset( new DefaultInputHandler ); } - //-------------------------------------------------------------------- - bool UnoControlTableColumn::isResizable() const + + //------------------------------------------------------------------------------------------------------------------ + UnoControlTableModel::~UnoControlTableModel() { - return m_bIsResizable; + DBG_DTOR( UnoControlTableModel, UnoControlTableModel_checkInvariants ); + DELETEZ( m_pImpl ); } - //-------------------------------------------------------------------- - void UnoControlTableColumn::setResizable( bool _bResizable ) + //------------------------------------------------------------------------------------------------------------------ + TableSize UnoControlTableModel::getColumnCount() const { - m_bIsResizable = _bResizable; + DBG_CHECK_ME(); + return (TableSize)m_pImpl->aColumns.size(); } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableColumn::getWidth() const + //------------------------------------------------------------------------------------------------------------------ + TableSize UnoControlTableModel::getRowCount() const { - return m_nWidth; + DBG_CHECK_ME(); + + TableSize nRowCount = 0; + try + { + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + ENSURE_OR_THROW( xDataModel.is(), "no data model anymore!" ); + nRowCount = xDataModel->getRowCount(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + return nRowCount; } - //-------------------------------------------------------------------- - void UnoControlTableColumn::setWidth( TableMetrics _nWidth ) + //------------------------------------------------------------------------------------------------------------------ + bool UnoControlTableModel::hasColumnHeaders() const { - m_nWidth = _nWidth; + DBG_CHECK_ME(); + return m_pImpl->bHasColumnHeaders; } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableColumn::getMinWidth() const + //------------------------------------------------------------------------------------------------------------------ + bool UnoControlTableModel::hasRowHeaders() const { - return m_nMinWidth; + DBG_CHECK_ME(); + return m_pImpl->bHasRowHeaders; } - //-------------------------------------------------------------------- - void UnoControlTableColumn::setMinWidth( TableMetrics _nMinWidth ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setRowHeaders(bool _bRowHeaders) { - m_nMinWidth = _nMinWidth; + DBG_CHECK_ME(); + if ( m_pImpl->bHasRowHeaders == _bRowHeaders ) + return; + + m_pImpl->bHasRowHeaders = _bRowHeaders; + impl_notifyTableMetricsChanged(); } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableColumn::getMaxWidth() const + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setColumnHeaders(bool _bColumnHeaders) { - return m_nMaxWidth; + DBG_CHECK_ME(); + if ( m_pImpl->bHasColumnHeaders == _bColumnHeaders ) + return; + + m_pImpl->bHasColumnHeaders = _bColumnHeaders; + impl_notifyTableMetricsChanged(); } - //-------------------------------------------------------------------- - void UnoControlTableColumn::setMaxWidth( TableMetrics _nMaxWidth ) + //------------------------------------------------------------------------------------------------------------------ + bool UnoControlTableModel::isCellEditable( ColPos col, RowPos row ) const { - m_nMaxWidth = _nMaxWidth; + DBG_CHECK_ME(); + (void)col; + (void)row; + return false; } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableColumn::getPreferredWidth() const + + //------------------------------------------------------------------------------------------------------------------ + PColumnModel UnoControlTableModel::getColumnModel( ColPos column ) { - return m_nPrefWidth; + DBG_CHECK_ME(); + ENSURE_OR_RETURN( ( column >= 0 ) && ( column < getColumnCount() ), + "DefaultTableModel::getColumnModel: invalid index!", PColumnModel() ); + return m_pImpl->aColumns[ column ]; } - //-------------------------------------------------------------------- - void UnoControlTableColumn::setPreferredWidth( TableMetrics _nPrefWidth ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::appendColumn( Reference< XGridColumn > const & i_column ) { - m_nPrefWidth = _nPrefWidth; + DBG_CHECK_ME(); + insertColumn( m_pImpl->aColumns.size(), i_column ); } - //-------------------------------------------------------------------- - ::com::sun::star::style::HorizontalAlignment UnoControlTableColumn::getHorizontalAlign() + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::insertColumn( ColPos const i_position, Reference< XGridColumn > const & i_column ) { - return m_xHorizontalAlign; + DBG_CHECK_ME(); + ENSURE_OR_RETURN_VOID( ( i_position >= 0 ) && ( size_t( i_position ) <= m_pImpl->aColumns.size() ), + "UnoControlTableModel::insertColumn: illegal position!" ); + + const PColumnModel pColumn( new UnoGridColumnFacade( *this, i_column ) ); + m_pImpl->aColumns.insert( m_pImpl->aColumns.begin() + i_position, pColumn ); + + // notify listeners + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->columnInserted( i_position ); + } } - //-------------------------------------------------------------------- - void UnoControlTableColumn::setHorizontalAlign( com::sun::star::style::HorizontalAlignment _align ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::removeColumn( ColPos const i_position ) { - m_xHorizontalAlign = _align; + DBG_CHECK_ME(); + ENSURE_OR_RETURN_VOID( ( i_position >= 0 ) && ( size_t( i_position ) <= m_pImpl->aColumns.size() ), + "UnoControlTableModel::removeColumn: illegal position!" ); + + // remove the column + ColumnModels::iterator pos = m_pImpl->aColumns.begin() + i_position; + const PColumnModel pColumn = *pos; + m_pImpl->aColumns.erase( pos ); + + // notify listeners + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->columnRemoved( i_position ); + } + + // dispose the column + UnoGridColumnFacade* pColumnImpl = dynamic_cast< UnoGridColumnFacade* >( pColumn.get() ); + OSL_ENSURE( pColumnImpl != NULL, "UnoControlTableModel::removeColumn: illegal column implementation!" ); + if ( pColumnImpl ) + pColumnImpl->dispose(); } - //==================================================================== - //= DefaultTableModel_Impl - //==================================================================== - struct UnoControlTableModel_Impl + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::removeAllColumns() { - ::std::vector< PColumnModel > aColumns; - TableSize nRowCount; - bool bHasColumnHeaders; - bool bHasRowHeaders; - bool bVScroll; - bool bHScroll; - PTableRenderer pRenderer; - PTableInputHandler pInputHandler; - TableMetrics nRowHeight; - TableMetrics nColumnHeaderHeight; - TableMetrics nRowHeaderWidth; - std::vector<rtl::OUString> aRowHeadersTitle; - std::vector<std::vector< Any > > aCellContent; - ::com::sun::star::util::Color m_xLineColor; - ::com::sun::star::util::Color m_xHeaderColor; - ::com::sun::star::util::Color m_xTextColor; - ::com::sun::star::util::Color m_xRowColor1; - ::com::sun::star::util::Color m_xRowColor2; - ::com::sun::star::style::VerticalAlignment m_xVerticalAlign; + DBG_CHECK_ME(); + if ( m_pImpl->aColumns.empty() ) + return; - UnoControlTableModel_Impl() - :aColumns ( ) - ,nRowCount ( 0 ) - ,bHasColumnHeaders ( false ) - ,bHasRowHeaders ( false ) - ,bVScroll ( false ) - ,bHScroll ( false ) - ,pRenderer ( ) - ,pInputHandler ( ) - ,nRowHeight ( 0 ) - ,nColumnHeaderHeight( 0 ) - ,nRowHeaderWidth ( 10 ) - ,aRowHeadersTitle ( ) - ,aCellContent ( ) - ,m_xLineColor ( 0xFFFFFF ) - ,m_xHeaderColor ( 0xFFFFFF ) - ,m_xTextColor ( 0 )//black as default - ,m_xRowColor1 ( 0xFFFFFF ) - ,m_xRowColor2 ( 0xFFFFFF ) - ,m_xVerticalAlign (com::sun::star::style::VerticalAlignment(0)) + // dispose the column instances + for ( ColumnModels::const_iterator col = m_pImpl->aColumns.begin(); + col != m_pImpl->aColumns.end(); + ++col + ) { + UnoGridColumnFacade* pColumn = dynamic_cast< UnoGridColumnFacade* >( col->get() ); + ENSURE_OR_CONTINUE( pColumn != NULL, "UnoControlTableModel::removeAllColumns: illegal column implementation!" ); + pColumn->dispose(); } - }; + m_pImpl->aColumns.clear(); + + // notify listeners + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->allColumnsRemoved(); + } + } - //==================================================================== - //= UnoControlTableModel - //==================================================================== - //-------------------------------------------------------------------- - UnoControlTableModel::UnoControlTableModel() - :m_pImpl( new UnoControlTableModel_Impl ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::impl_notifyTableMetricsChanged() const { - m_pImpl->bHasColumnHeaders = false; - m_pImpl->bHasRowHeaders = false; - m_pImpl->pRenderer.reset( new GridTableRenderer( *this ) ); - m_pImpl->pInputHandler.reset( new DefaultInputHandler ); + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->tableMetricsChanged(); + } } - //-------------------------------------------------------------------- - UnoControlTableModel::~UnoControlTableModel() + //------------------------------------------------------------------------------------------------------------------ + PTableRenderer UnoControlTableModel::getRenderer() const { - DELETEZ( m_pImpl ); + DBG_CHECK_ME(); + return m_pImpl->pRenderer; } - //-------------------------------------------------------------------- - TableSize UnoControlTableModel::getColumnCount() const + //------------------------------------------------------------------------------------------------------------------ + PTableInputHandler UnoControlTableModel::getInputHandler() const { - return (TableSize)m_pImpl->aColumns.size(); + DBG_CHECK_ME(); + return m_pImpl->pInputHandler; } - //-------------------------------------------------------------------- - TableSize UnoControlTableModel::getRowCount() const + //------------------------------------------------------------------------------------------------------------------ + TableMetrics UnoControlTableModel::getRowHeight() const { - return m_pImpl->nRowCount; + DBG_CHECK_ME(); + return m_pImpl->nRowHeight; } - //-------------------------------------------------------------------- - bool UnoControlTableModel::hasColumnHeaders() const + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setRowHeight(TableMetrics _nRowHeight) { - return m_pImpl->bHasColumnHeaders; + DBG_CHECK_ME(); + if ( m_pImpl->nRowHeight == _nRowHeight ) + return; + + m_pImpl->nRowHeight = _nRowHeight; + impl_notifyTableMetricsChanged(); } - //-------------------------------------------------------------------- - bool UnoControlTableModel::hasRowHeaders() const + //------------------------------------------------------------------------------------------------------------------ + TableMetrics UnoControlTableModel::getColumnHeaderHeight() const { - return m_pImpl->bHasRowHeaders; + DBG_CHECK_ME(); + DBG_ASSERT( hasColumnHeaders(), "DefaultTableModel::getColumnHeaderHeight: invalid call!" ); + return m_pImpl->nColumnHeaderHeight; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setRowHeaders(bool _bRowHeaders) + //------------------------------------------------------------------------------------------------------------------ + TableMetrics UnoControlTableModel::getRowHeaderWidth() const { - m_pImpl->bHasRowHeaders = _bRowHeaders; + DBG_CHECK_ME(); + DBG_ASSERT( hasRowHeaders(), "DefaultTableModel::getRowHeaderWidth: invalid call!" ); + return m_pImpl->nRowHeaderWidth; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setColumnHeaders(bool _bColumnHeaders) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setColumnHeaderHeight(TableMetrics _nHeight) { - m_pImpl->bHasColumnHeaders = _bColumnHeaders; + DBG_CHECK_ME(); + if ( m_pImpl->nColumnHeaderHeight == _nHeight ) + return; + + m_pImpl->nColumnHeaderHeight = _nHeight; + impl_notifyTableMetricsChanged(); } - void UnoControlTableModel::setColumnCount(TableSize _nColCount) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setRowHeaderWidth(TableMetrics _nWidth) { - m_pImpl->aColumns.resize( _nColCount); + DBG_CHECK_ME(); + if ( m_pImpl->nRowHeaderWidth == _nWidth ) + return; + + m_pImpl->nRowHeaderWidth = _nWidth; + impl_notifyTableMetricsChanged(); } - //-------------------------------------------------------------------- - void UnoControlTableModel::setRowCount(TableSize _nRowCount) + + //------------------------------------------------------------------------------------------------------------------ + ScrollbarVisibility UnoControlTableModel::getVerticalScrollbarVisibility() const { - m_pImpl->nRowCount = _nRowCount; + DBG_CHECK_ME(); + return m_pImpl->eVScrollMode; } - //-------------------------------------------------------------------- - bool UnoControlTableModel::isCellEditable( ColPos col, RowPos row ) const + + //------------------------------------------------------------------------------------------------------------------ + ScrollbarVisibility UnoControlTableModel::getHorizontalScrollbarVisibility() const { - (void)col; - (void)row; - return false; + DBG_CHECK_ME(); + return m_pImpl->eHScrollMode; } - //-------------------------------------------------------------------- - void UnoControlTableModel::addTableModelListener( const PTableModelListener& listener ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::addTableModelListener( const PTableModelListener& i_listener ) { - (void) listener; - // TODO - DBG_ERROR( "DefaultTableModel::addTableModelListener: not yet implemented!" ); + DBG_CHECK_ME(); + ENSURE_OR_RETURN_VOID( !!i_listener, "illegal NULL listener" ); + m_pImpl->m_aListeners.push_back( i_listener ); } - //-------------------------------------------------------------------- - void UnoControlTableModel::removeTableModelListener( const PTableModelListener& listener ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::removeTableModelListener( const PTableModelListener& i_listener ) { - (void)listener; - // TODO - DBG_ERROR( "DefaultTableModel::removeTableModelListener: not yet implemented!" ); + DBG_CHECK_ME(); + for ( ModellListeners::iterator lookup = m_pImpl->m_aListeners.begin(); + lookup != m_pImpl->m_aListeners.end(); + ++lookup + ) + { + if ( *lookup == i_listener ) + { + m_pImpl->m_aListeners.erase( lookup ); + return; + } + } + OSL_ENSURE( false, "UnoControlTableModel::removeTableModelListener: listener is not registered - sure you're doing the right thing here?" ); } - //-------------------------------------------------------------------- - PColumnModel UnoControlTableModel::getColumnModel( ColPos column ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setVerticalScrollbarVisibility( ScrollbarVisibility const i_visibility ) const { - DBG_ASSERT( ( column >= 0 ) && ( column < getColumnCount() ), - "DefaultTableModel::getColumnModel: invalid index!" ); - return m_pImpl->aColumns[ column ]; + DBG_CHECK_ME(); + m_pImpl->eVScrollMode = i_visibility; } - //-------------------------------------------------------------------- - std::vector<PColumnModel>& UnoControlTableModel::getColumnModel() + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setHorizontalScrollbarVisibility( ScrollbarVisibility const i_visibility ) const { - return m_pImpl->aColumns; + DBG_CHECK_ME(); + m_pImpl->eHScrollMode = i_visibility; } - //-------------------------------------------------------------------- - PColumnModel UnoControlTableModel::getColumnModelByID( ColumnID id ) + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setDataModel( Reference< XGridDataModel > const & i_gridDataModel ) { - (void)id; - // TODO - DBG_ERROR( "DefaultTableModel::getColumnModelByID: not yet implemented!" ); - return PColumnModel(); + DBG_CHECK_ME(); + m_pImpl->m_aDataModel = i_gridDataModel; + // TODO: register as listener, so we're notified of row/data changes, and can multiplex them to our + // own listeners } - //-------------------------------------------------------------------- - PTableRenderer UnoControlTableModel::getRenderer() const + //------------------------------------------------------------------------------------------------------------------ + Reference< XGridDataModel > UnoControlTableModel::getDataModel() const { - return m_pImpl->pRenderer; + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + return xDataModel; } - //-------------------------------------------------------------------- - PTableInputHandler UnoControlTableModel::getInputHandler() const + //------------------------------------------------------------------------------------------------------------------ + bool UnoControlTableModel::hasDataModel() const { - return m_pImpl->pInputHandler; + return getDataModel().is(); } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableModel::getRowHeight() const + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setColumnModel( Reference< XGridColumnModel > const & i_gridColumnModel ) { - return m_pImpl->nRowHeight; + DBG_CHECK_ME(); + m_pImpl->m_aColumnModel = i_gridColumnModel; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setRowHeight(TableMetrics _nRowHeight) + + //------------------------------------------------------------------------------------------------------------------ + Reference< XGridColumnModel > UnoControlTableModel::getColumnModel() const { - m_pImpl->nRowHeight = _nRowHeight; + Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel ); + return xColumnModel; } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableModel::getColumnHeaderHeight() const + //------------------------------------------------------------------------------------------------------------------ + bool UnoControlTableModel::hasColumnModel() const { - DBG_ASSERT( hasColumnHeaders(), "DefaultTableModel::getColumnHeaderHeight: invalid call!" ); - return m_pImpl->nColumnHeaderHeight; + return getColumnModel().is(); } - //-------------------------------------------------------------------- - TableMetrics UnoControlTableModel::getRowHeaderWidth() const + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::getCellContent( ColPos const i_col, RowPos const i_row, Any& o_cellContent ) { - DBG_ASSERT( hasRowHeaders(), "DefaultTableModel::getRowHeaderWidth: invalid call!" ); - return m_pImpl->nRowHeaderWidth; + DBG_CHECK_ME(); + + o_cellContent.clear(); + try + { + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + ENSURE_OR_RETURN_VOID( xDataModel.is(), "UnoControlTableModel::getCellContent: no data model anymore!" ); + + PColumnModel const pColumn = getColumnModel( i_col ); + UnoGridColumnFacade* pColumnImpl = dynamic_cast< UnoGridColumnFacade* >( pColumn.get() ); + ENSURE_OR_RETURN_VOID( pColumnImpl != NULL, "UnoControlTableModel::getCellContent: no (valid) column at this position!" ); + sal_Int32 const nDataColumnIndex = pColumnImpl->getDataColumnIndex() >= 0 ? pColumnImpl->getDataColumnIndex() : i_col; + + if ( nDataColumnIndex >= xDataModel->getColumnCount() ) + { + // this is allowed, in case the column model has been dynamically extended, but the data model does + // not (yet?) know about it. + // So, handle it gracefully. + #if OSL_DEBUG_LEVEL > 0 + { + Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel ); + OSL_ENSURE( xColumnModel.is() && i_col < xColumnModel->getColumnCount(), + "UnoControlTableModel::getCellContent: request a column's value which the ColumnModel doesn't know about!" ); + } + #endif + } + else + { + o_cellContent = xDataModel->getCellData( nDataColumnIndex, i_row ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } } - //-------------------------------------------------------------------- - void UnoControlTableModel::setColumnHeaderHeight(TableMetrics _nHeight) + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::getCellToolTip( ColPos const i_col, RowPos const i_row, Any& o_cellToolTip ) { - m_pImpl->nColumnHeaderHeight = _nHeight; + DBG_CHECK_ME(); + try + { + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + ENSURE_OR_THROW( xDataModel.is(), "no data model anymore!" ); + + o_cellToolTip = xDataModel->getCellToolTip( i_col, i_row ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } } - //-------------------------------------------------------------------- - void UnoControlTableModel::setRowHeaderWidth(TableMetrics _nWidth) + //------------------------------------------------------------------------------------------------------------------ + Any UnoControlTableModel::getRowHeading( RowPos const i_rowPos ) const { - m_pImpl->nRowHeaderWidth = _nWidth; + DBG_CHECK_ME(); + + Any aRowHeading; + + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + ENSURE_OR_RETURN( xDataModel.is(), "UnoControlTableModel::getRowHeading: no data model anymore!", aRowHeading ); + + try + { + aRowHeading = xDataModel->getRowHeading( i_rowPos ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + return aRowHeading; } - //-------------------------------------------------------------------- - void UnoControlTableModel::SetTitleHeight( TableMetrics _nHeight ) + //------------------------------------------------------------------------------------------------------------------ + namespace { - DBG_ASSERT( _nHeight > 0, "DefaultTableModel::SetTitleHeight: invalid height value!" ); - m_pImpl->nColumnHeaderHeight = _nHeight; - // TODO: notification + void lcl_setColor( Any const & i_color, ::boost::optional< ::Color > & o_convertedColor ) + { + if ( !i_color.hasValue() ) + o_convertedColor.reset(); + else + { + sal_Int32 nColor = COL_TRANSPARENT; + if ( i_color >>= nColor ) + { + o_convertedColor.reset( ::Color( nColor ) ); + } + else + { + OSL_ENSURE( false, "lcl_setColor: could not extract color value!" ); + } + } + } } - //-------------------------------------------------------------------- - void UnoControlTableModel::SetHandleWidth( TableMetrics _nWidth ) + //------------------------------------------------------------------------------------------------------------------ + ::boost::optional< ::Color > UnoControlTableModel::getLineColor() const { - DBG_ASSERT( _nWidth > 0, "DefaultTableModel::SetHandleWidth: invalid width value!" ); - m_pImpl->nRowHeaderWidth = _nWidth; - // TODO: notification + DBG_CHECK_ME(); + return m_pImpl->m_aGridLineColor; } - //-------------------------------------------------------------------- - ScrollbarVisibility UnoControlTableModel::getVerticalScrollbarVisibility(int overAllHeight, int actHeight) const + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setLineColor( Any const & i_color ) { - if(overAllHeight>=actHeight && !m_pImpl->bVScroll) - return ScrollbarShowNever; - else - return ScrollbarShowAlways; + DBG_CHECK_ME(); + lcl_setColor( i_color, m_pImpl->m_aGridLineColor ); } - //-------------------------------------------------------------------- - ScrollbarVisibility UnoControlTableModel::getHorizontalScrollbarVisibility(int overAllWidth, int actWidth) const + //------------------------------------------------------------------------------------------------------------------ + ::boost::optional< ::Color > UnoControlTableModel::getHeaderBackgroundColor() const { - if(overAllWidth>=actWidth && !m_pImpl->bHScroll) - return ScrollbarShowNever; - else - return ScrollbarShowAlways; + DBG_CHECK_ME(); + return m_pImpl->m_aHeaderBackgroundColor; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setVerticalScrollbarVisibility(bool _bVScroll) const + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setHeaderBackgroundColor( Any const & i_color ) { - m_pImpl->bVScroll = _bVScroll; + DBG_CHECK_ME(); + lcl_setColor( i_color, m_pImpl->m_aHeaderBackgroundColor ); } - //-------------------------------------------------------------------- - void UnoControlTableModel::setHorizontalScrollbarVisibility(bool _bHScroll) const + //------------------------------------------------------------------------------------------------------------------ + ::boost::optional< ::Color > UnoControlTableModel::getHeaderTextColor() const { - m_pImpl->bHScroll = _bHScroll; + DBG_CHECK_ME(); + return m_pImpl->m_aHeaderTextColor; } - //-------------------------------------------------------------------- - bool UnoControlTableModel::hasVerticalScrollbar() + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setHeaderTextColor( Any const & i_color ) { - return m_pImpl->bVScroll; + DBG_CHECK_ME(); + lcl_setColor( i_color, m_pImpl->m_aHeaderTextColor ); } - //-------------------------------------------------------------------- - bool UnoControlTableModel::hasHorizontalScrollbar() + + //------------------------------------------------------------------------------------------------------------------ + ::boost::optional< ::Color > UnoControlTableModel::getTextColor() const { - return m_pImpl->bHScroll; + DBG_CHECK_ME(); + return m_pImpl->m_aTextColor; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setCellContent(const std::vector<std::vector< Any > >& cellContent) + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setTextColor( Any const & i_color ) { - m_pImpl->aCellContent = cellContent; + DBG_CHECK_ME(); + lcl_setColor( i_color, m_pImpl->m_aTextColor ); } - std::vector<std::vector< Any > >& UnoControlTableModel::getCellContent() + //------------------------------------------------------------------------------------------------------------------ + ::boost::optional< ::Color > UnoControlTableModel::getTextLineColor() const { - return m_pImpl->aCellContent; + DBG_CHECK_ME(); + return m_pImpl->m_aTextColor; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setRowHeaderName(const std::vector<rtl::OUString>& cellColumnContent) + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setTextLineColor( Any const & i_color ) { - m_pImpl->aRowHeadersTitle = cellColumnContent; + DBG_CHECK_ME(); + lcl_setColor( i_color, m_pImpl->m_aTextLineColor ); } - std::vector<rtl::OUString>& UnoControlTableModel::getRowHeaderName() + //------------------------------------------------------------------------------------------------------------------ + ::boost::optional< ::std::vector< ::Color > > UnoControlTableModel::getRowBackgroundColors() const { - return m_pImpl->aRowHeadersTitle; + DBG_CHECK_ME(); + return m_pImpl->m_aRowColors; } - //-------------------------------------------------------------------- - ::com::sun::star::util::Color UnoControlTableModel::getLineColor() + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setRowBackgroundColors( ::com::sun::star::uno::Any const & i_APIValue ) { - return m_pImpl->m_xLineColor; + DBG_CHECK_ME(); + Sequence< ::com::sun::star::util::Color > aAPIColors; + if ( !( i_APIValue >>= aAPIColors ) ) + m_pImpl->m_aRowColors.reset(); + else + { + ::std::vector< ::Color > aColors( aAPIColors.getLength() ); + for ( sal_Int32 i=0; i<aAPIColors.getLength(); ++i ) + { + aColors[i] = ::Color( aAPIColors[i] ); + } + m_pImpl->m_aRowColors.reset( aColors ); + } } - //-------------------------------------------------------------------- - void UnoControlTableModel::setLineColor( ::com::sun::star::util::Color _rColor ) + //------------------------------------------------------------------------------------------------------------------ + VerticalAlignment UnoControlTableModel::getVerticalAlign() const { - m_pImpl->m_xLineColor = _rColor; + DBG_CHECK_ME(); + return m_pImpl->m_eVerticalAlign; } - //-------------------------------------------------------------------- - ::com::sun::star::util::Color UnoControlTableModel::getHeaderBackgroundColor() + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::setVerticalAlign( VerticalAlignment _xAlign ) { - return m_pImpl->m_xHeaderColor; + DBG_CHECK_ME(); + m_pImpl->m_eVerticalAlign = _xAlign; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setHeaderBackgroundColor( ::com::sun::star::util::Color _rColor ) + //------------------------------------------------------------------------------------------------------------------ + ColPos UnoControlTableModel::getColumnPos( UnoGridColumnFacade const & i_column ) const { - m_pImpl->m_xHeaderColor = _rColor; + DBG_CHECK_ME(); + for ( ColumnModels::const_iterator col = m_pImpl->aColumns.begin(); + col != m_pImpl->aColumns.end(); + ++col + ) + { + if ( &i_column == col->get() ) + return col - m_pImpl->aColumns.begin(); + } + OSL_ENSURE( false, "UnoControlTableModel::getColumnPos: column not found!" ); + return COL_INVALID; } - //-------------------------------------------------------------------- - ::com::sun::star::util::Color UnoControlTableModel::getTextColor() + + //------------------------------------------------------------------------------------------------------------------ + ITableDataSort* UnoControlTableModel::getSortAdapter() { - return m_pImpl->m_xTextColor; + DBG_CHECK_ME(); + + Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY ); + if ( xSortAccess.is() ) + return this; + return NULL; } - //-------------------------------------------------------------------- - void UnoControlTableModel::setTextColor( ::com::sun::star::util::Color _rColor ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::sortByColumn( ColPos const i_column, ColumnSortDirection const i_sortDirection ) { - m_pImpl->m_xTextColor = _rColor; + DBG_CHECK_ME(); + + try + { + Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY_THROW ); + xSortAccess->sortByColumn( i_column, i_sortDirection == ColumnSortAscending ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } } - //-------------------------------------------------------------------- - ::com::sun::star::util::Color UnoControlTableModel::getOddRowBackgroundColor() + + //------------------------------------------------------------------------------------------------------------------ + ColumnSort UnoControlTableModel::getCurrentSortOrder() const { - return m_pImpl->m_xRowColor1; + DBG_CHECK_ME(); + + ColumnSort currentSort; + try + { + Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY_THROW ); + Pair< ::sal_Int32, ::sal_Bool > const aCurrentSortOrder( xSortAccess->getCurrentSortOrder() ); + currentSort.nColumnPos = aCurrentSortOrder.First; + currentSort.eSortDirection = aCurrentSortOrder.Second ? ColumnSortAscending : ColumnSortDescending; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + return currentSort; } //-------------------------------------------------------------------- - void UnoControlTableModel::setOddRowBackgroundColor( ::com::sun::star::util::Color _rColor ) + void UnoControlTableModel::notifyColumnChange( ColPos const i_columnPos, ColumnAttributeGroup const i_attributeGroup ) const { - m_pImpl->m_xRowColor1 = _rColor; + DBG_CHECK_ME(); + ENSURE_OR_RETURN_VOID( ( i_columnPos >= 0 ) && ( i_columnPos < getColumnCount() ), + "UnoControlTableModel::notifyColumnChange: invalid column index!" ); + + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->columnChanged( i_columnPos, i_attributeGroup ); + } } - //-------------------------------------------------------------------- - ::com::sun::star::util::Color UnoControlTableModel::getEvenRowBackgroundColor() + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::notifyRowsInserted( GridDataEvent const & i_event ) const { - return m_pImpl->m_xRowColor2; + // check sanity of the event + ENSURE_OR_RETURN_VOID( i_event.FirstRow >= 0, "UnoControlTableModel::notifyRowsInserted: invalid first row!" ); + ENSURE_OR_RETURN_VOID( i_event.LastRow >= i_event.FirstRow, "UnoControlTableModel::notifyRowsInserted: invalid row indexes!" ); + + // check own sanity + Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel ); + ENSURE_OR_RETURN_VOID( xColumnModel.is(), "UnoControlTableModel::notifyRowsInserted: no column model anymore!" ); + + Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel ); + ENSURE_OR_RETURN_VOID( xDataModel.is(), "UnoControlTableModel::notifyRowsInserted: no data model anymore!" ); + + // implicitly add columns to the column model + // TODO: is this really a good idea? + sal_Int32 const dataColumnCount = xDataModel->getColumnCount(); + OSL_ENSURE( dataColumnCount > 0, "UnoControlTableModel::notifyRowsInserted: no columns at all?" ); + + sal_Int32 const modelColumnCount = xColumnModel->getColumnCount(); + if ( ( modelColumnCount == 0 ) && ( dataColumnCount > 0 ) ) + { + // TODO: shouldn't we clear the mutexes guard for this call? + xColumnModel->setDefaultColumns( dataColumnCount ); + } + + // multiplex the event to our own listeners + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->rowsInserted( i_event.FirstRow, i_event.LastRow ); + } } - //-------------------------------------------------------------------- - void UnoControlTableModel::setEvenRowBackgroundColor( ::com::sun::star::util::Color _rColor ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::notifyRowsRemoved( GridDataEvent const & i_event ) const { - m_pImpl->m_xRowColor2 = _rColor; + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->rowsRemoved( i_event.FirstRow, i_event.LastRow ); + } } - //-------------------------------------------------------------------- - ::com::sun::star::style::VerticalAlignment UnoControlTableModel::getVerticalAlign() + + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::notifyDataChanged( ::com::sun::star::awt::grid::GridDataEvent const & i_event ) const { - return m_pImpl->m_xVerticalAlign; + ColPos const firstCol = i_event.FirstColumn == -1 ? 0 : i_event.FirstColumn; + ColPos const lastCol = i_event.FirstColumn == -1 ? getColumnCount() - 1 : i_event.LastColumn; + RowPos const firstRow = i_event.FirstRow == -1 ? 0 : i_event.FirstRow; + RowPos const lastRow = i_event.FirstRow == -1 ? getRowCount() - 1 : i_event.LastRow; + + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->cellsUpdated( firstCol, lastCol, firstRow, lastRow ); + } } - //-------------------------------------------------------------------- - void UnoControlTableModel::setVerticalAlign( com::sun::star::style::VerticalAlignment _xAlign ) + //------------------------------------------------------------------------------------------------------------------ + void UnoControlTableModel::notifyAllDataChanged() const { - m_pImpl->m_xVerticalAlign = _xAlign; + ModellListeners aListeners( m_pImpl->m_aListeners ); + for ( ModellListeners::const_iterator loop = aListeners.begin(); + loop != aListeners.end(); + ++loop + ) + { + (*loop)->cellsUpdated( 0, getColumnCount() - 1, 0, getRowCount() - 1 ); + } } +// ..................................................................................................................... +} } // svt::table +// ..................................................................................................................... |