LCOV - code coverage report
Current view: top level - svtools/source/uno - unocontroltablemodel.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 188 321 58.6 %
Date: 2014-11-03 Functions: 52 77 67.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "unocontroltablemodel.hxx"
      21             : #include "unogridcolumnfacade.hxx"
      22             : 
      23             : #include "table/defaultinputhandler.hxx"
      24             : #include "table/gridtablerenderer.hxx"
      25             : #include "table/tablecontrol.hxx"
      26             : 
      27             : #include <com/sun/star/awt/grid/XGridColumn.hpp>
      28             : #include <com/sun/star/view/SelectionType.hpp>
      29             : #include <com/sun/star/awt/grid/XGridColumnListener.hpp>
      30             : #include <com/sun/star/awt/grid/XSortableGridData.hpp>
      31             : 
      32             : #include <cppuhelper/weakref.hxx>
      33             : #include <tools/debug.hxx>
      34             : #include <tools/diagnose_ex.h>
      35             : #include <vcl/svapp.hxx>
      36             : #include <osl/mutex.hxx>
      37             : 
      38             : 
      39             : namespace svt { namespace table
      40             : {
      41             : 
      42             : 
      43             :     using ::com::sun::star::uno::Reference;
      44             :     using ::com::sun::star::uno::RuntimeException;
      45             :     using ::com::sun::star::uno::Sequence;
      46             :     using ::com::sun::star::uno::UNO_QUERY_THROW;
      47             :     using ::com::sun::star::uno::UNO_QUERY;
      48             :     using ::com::sun::star::awt::grid::XGridColumn;
      49             :     using ::com::sun::star::uno::XInterface;
      50             :     using ::com::sun::star::uno::Exception;
      51             :     using ::com::sun::star::awt::grid::XGridColumnListener;
      52             :     using ::com::sun::star::lang::EventObject;
      53             :     using ::com::sun::star::awt::grid::GridColumnEvent;
      54             :     using ::com::sun::star::awt::grid::XGridDataModel;
      55             :     using ::com::sun::star::awt::grid::XGridColumnModel;
      56             :     using ::com::sun::star::uno::Any;
      57             :     using ::com::sun::star::style::HorizontalAlignment_LEFT;
      58             :     using ::com::sun::star::style::HorizontalAlignment;
      59             :     using ::com::sun::star::style::VerticalAlignment_TOP;
      60             :     using ::com::sun::star::style::VerticalAlignment;
      61             :     using ::com::sun::star::uno::WeakReference;
      62             :     using ::com::sun::star::awt::grid::GridDataEvent;
      63             :     using ::com::sun::star::awt::grid::XSortableGridData;
      64             :     using ::com::sun::star::beans::Pair;
      65             : 
      66             : 
      67             :     //= UnoControlTableModel_Impl
      68             : 
      69             :     typedef ::std::vector< PTableModelListener >    ModellListeners;
      70             :     typedef ::std::vector< PColumnModel >           ColumnModels;
      71           2 :     struct UnoControlTableModel_Impl
      72             :     {
      73             :         ColumnModels                                    aColumns;
      74             :         bool                                            bHasColumnHeaders;
      75             :         bool                                            bHasRowHeaders;
      76             :         ScrollbarVisibility                             eVScrollMode;
      77             :         ScrollbarVisibility                             eHScrollMode;
      78             :         PTableRenderer                                  pRenderer;
      79             :         PTableInputHandler                              pInputHandler;
      80             :         TableMetrics                                    nRowHeight;
      81             :         TableMetrics                                    nColumnHeaderHeight;
      82             :         TableMetrics                                    nRowHeaderWidth;
      83             :         ::boost::optional< ::Color >                    m_aGridLineColor;
      84             :         ::boost::optional< ::Color >                    m_aHeaderBackgroundColor;
      85             :         ::boost::optional< ::Color >                    m_aHeaderTextColor;
      86             :         ::boost::optional< ::Color >                    m_aActiveSelectionBackColor;
      87             :         ::boost::optional< ::Color >                    m_aInactiveSelectionBackColor;
      88             :         ::boost::optional< ::Color >                    m_aActiveSelectionTextColor;
      89             :         ::boost::optional< ::Color >                    m_aInactiveSelectionTextColor;
      90             :         ::boost::optional< ::Color >                    m_aTextColor;
      91             :         ::boost::optional< ::Color >                    m_aTextLineColor;
      92             :         ::boost::optional< ::std::vector< ::Color > >   m_aRowColors;
      93             :         VerticalAlignment                               m_eVerticalAlign;
      94             :         bool                                            bEnabled;
      95             :         ModellListeners                                 m_aListeners;
      96             :         WeakReference< XGridDataModel >                 m_aDataModel;
      97             :         WeakReference< XGridColumnModel >               m_aColumnModel;
      98             : 
      99           2 :         UnoControlTableModel_Impl()
     100             :             :aColumns                       ( )
     101             :             ,bHasColumnHeaders              ( true      )
     102             :             ,bHasRowHeaders                 ( false     )
     103             :             ,eVScrollMode                   ( ScrollbarShowNever )
     104             :             ,eHScrollMode                   ( ScrollbarShowNever )
     105             :             ,pRenderer                      ( )
     106             :             ,pInputHandler                  ( )
     107             :             ,nRowHeight                     ( 10 )
     108             :             ,nColumnHeaderHeight            ( 10 )
     109             :             ,nRowHeaderWidth                ( 10 )
     110             :             ,m_aGridLineColor               ( )
     111             :             ,m_aHeaderBackgroundColor       ( )
     112             :             ,m_aHeaderTextColor             ( )
     113             :             ,m_aActiveSelectionBackColor    ( )
     114             :             ,m_aInactiveSelectionBackColor  ( )
     115             :             ,m_aActiveSelectionTextColor    ( )
     116             :             ,m_aInactiveSelectionTextColor  ( )
     117             :             ,m_aTextColor                   ( )
     118             :             ,m_aTextLineColor               ( )
     119             :             ,m_aRowColors                   ( )
     120             :             ,m_eVerticalAlign               ( VerticalAlignment_TOP )
     121           2 :             ,bEnabled                       ( true )
     122             :         {
     123           2 :         }
     124             :     };
     125             : 
     126             :     //= UnoControlTableModel
     127             : #define DBG_CHECK_ME() \
     128             :     DBG_TESTSOLARMUTEX(); \
     129             : 
     130           2 :     UnoControlTableModel::UnoControlTableModel()
     131           2 :         :m_pImpl( new UnoControlTableModel_Impl )
     132             :     {
     133           2 :         m_pImpl->bHasColumnHeaders = true;
     134           2 :         m_pImpl->bHasRowHeaders = false;
     135           2 :         m_pImpl->bEnabled = true;
     136           2 :         m_pImpl->pRenderer.reset( new GridTableRenderer( *this ) );
     137           2 :         m_pImpl->pInputHandler.reset( new DefaultInputHandler );
     138           2 :     }
     139             : 
     140             : 
     141           6 :     UnoControlTableModel::~UnoControlTableModel()
     142             :     {
     143           2 :         DELETEZ( m_pImpl );
     144           4 :     }
     145             : 
     146             : 
     147         192 :     TableSize UnoControlTableModel::getColumnCount() const
     148             :     {
     149             :         DBG_CHECK_ME();
     150         192 :         return (TableSize)m_pImpl->aColumns.size();
     151             :     }
     152             : 
     153             : 
     154          12 :     TableSize UnoControlTableModel::getRowCount() const
     155             :     {
     156             :         DBG_CHECK_ME();
     157             : 
     158          12 :         TableSize nRowCount = 0;
     159             :         try
     160             :         {
     161          12 :             Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
     162          12 :             ENSURE_OR_THROW( xDataModel.is(), "no data model anymore!" );
     163          12 :             nRowCount = xDataModel->getRowCount();
     164             :         }
     165           0 :         catch( const Exception& )
     166             :         {
     167             :             DBG_UNHANDLED_EXCEPTION();
     168             :         }
     169          12 :         return nRowCount;
     170             :     }
     171             : 
     172             : 
     173           2 :     bool UnoControlTableModel::hasColumnHeaders() const
     174             :     {
     175             :         DBG_CHECK_ME();
     176           2 :         return m_pImpl->bHasColumnHeaders;
     177             :     }
     178             : 
     179             : 
     180          42 :     bool UnoControlTableModel::hasRowHeaders() const
     181             :     {
     182             :         DBG_CHECK_ME();
     183          42 :         return m_pImpl->bHasRowHeaders;
     184             :     }
     185             : 
     186             : 
     187           2 :     void UnoControlTableModel::setRowHeaders(bool _bRowHeaders)
     188             :     {
     189             :         DBG_CHECK_ME();
     190           2 :         if ( m_pImpl->bHasRowHeaders == _bRowHeaders )
     191           4 :             return;
     192             : 
     193           0 :         m_pImpl->bHasRowHeaders = _bRowHeaders;
     194           0 :         impl_notifyTableMetricsChanged();
     195             :     }
     196             : 
     197             : 
     198           2 :     void UnoControlTableModel::setColumnHeaders(bool _bColumnHeaders)
     199             :     {
     200             :         DBG_CHECK_ME();
     201           2 :         if ( m_pImpl->bHasColumnHeaders == _bColumnHeaders )
     202           4 :             return;
     203             : 
     204           0 :         m_pImpl->bHasColumnHeaders = _bColumnHeaders;
     205           0 :         impl_notifyTableMetricsChanged();
     206             :     }
     207             : 
     208             : 
     209           0 :     bool UnoControlTableModel::isCellEditable( ColPos col, RowPos row ) const
     210             :     {
     211             :         DBG_CHECK_ME();
     212             :         (void)col;
     213             :         (void)row;
     214           0 :         return false;
     215             :     }
     216             : 
     217             : 
     218          96 :     PColumnModel UnoControlTableModel::getColumnModel( ColPos column )
     219             :     {
     220             :         DBG_CHECK_ME();
     221          96 :         ENSURE_OR_RETURN( ( column >= 0 ) && ( column < getColumnCount() ),
     222             :             "DefaultTableModel::getColumnModel: invalid index!", PColumnModel() );
     223          96 :         return m_pImpl->aColumns[ column ];
     224             :     }
     225             : 
     226             : 
     227           0 :     void UnoControlTableModel::appendColumn( Reference< XGridColumn > const & i_column )
     228             :     {
     229             :         DBG_CHECK_ME();
     230           0 :         insertColumn( m_pImpl->aColumns.size(), i_column );
     231           0 :     }
     232             : 
     233             : 
     234           6 :     void UnoControlTableModel::insertColumn( ColPos const i_position, Reference< XGridColumn > const & i_column )
     235             :     {
     236             :         DBG_CHECK_ME();
     237          12 :         ENSURE_OR_RETURN_VOID( ( i_position >= 0 ) && ( size_t( i_position ) <= m_pImpl->aColumns.size() ),
     238             :             "UnoControlTableModel::insertColumn: illegal position!" );
     239             : 
     240           6 :         const PColumnModel pColumn( new UnoGridColumnFacade( *this, i_column ) );
     241           6 :         m_pImpl->aColumns.insert( m_pImpl->aColumns.begin() + i_position, pColumn );
     242             : 
     243             :         // notify listeners
     244          12 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     245          36 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     246          24 :                 loop != aListeners.end();
     247             :                 ++loop
     248             :             )
     249             :         {
     250           6 :             (*loop)->columnInserted( i_position );
     251           6 :         }
     252             :     }
     253             : 
     254             : 
     255           2 :     void UnoControlTableModel::removeColumn( ColPos const i_position )
     256             :     {
     257             :         DBG_CHECK_ME();
     258           4 :         ENSURE_OR_RETURN_VOID( ( i_position >= 0 ) && ( size_t( i_position ) <= m_pImpl->aColumns.size() ),
     259             :             "UnoControlTableModel::removeColumn: illegal position!" );
     260             : 
     261             :         // remove the column
     262           2 :         ColumnModels::iterator pos = m_pImpl->aColumns.begin() + i_position;
     263           2 :         const PColumnModel pColumn = *pos;
     264           2 :         m_pImpl->aColumns.erase( pos );
     265             : 
     266             :         // notify listeners
     267           4 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     268          12 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     269           8 :                 loop != aListeners.end();
     270             :                 ++loop
     271             :             )
     272             :         {
     273           2 :             (*loop)->columnRemoved( i_position );
     274             :         }
     275             : 
     276             :         // dispose the column
     277           2 :         UnoGridColumnFacade* pColumnImpl = dynamic_cast< UnoGridColumnFacade* >( pColumn.get() );
     278             :         OSL_ENSURE( pColumnImpl != NULL, "UnoControlTableModel::removeColumn: illegal column implementation!" );
     279           2 :         if ( pColumnImpl )
     280           4 :             pColumnImpl->dispose();
     281             :     }
     282             : 
     283             : 
     284           2 :     void UnoControlTableModel::removeAllColumns()
     285             :     {
     286             :         DBG_CHECK_ME();
     287           2 :         if ( m_pImpl->aColumns.empty() )
     288           4 :             return;
     289             : 
     290             :         // dispose the column instances
     291           0 :         for (   ColumnModels::const_iterator col = m_pImpl->aColumns.begin();
     292           0 :                 col != m_pImpl->aColumns.end();
     293             :                 ++col
     294             :             )
     295             :         {
     296           0 :             UnoGridColumnFacade* pColumn = dynamic_cast< UnoGridColumnFacade* >( col->get() );
     297           0 :             if ( !pColumn )
     298             :             {
     299             :                 SAL_WARN( "svtools.uno", "UnoControlTableModel::removeAllColumns: illegal column implementation!" );
     300           0 :                 continue;
     301             :             }
     302             : 
     303           0 :             pColumn->dispose();
     304             :         }
     305           0 :         m_pImpl->aColumns.clear();
     306             : 
     307             :         // notify listeners
     308           0 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     309           0 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     310           0 :                 loop != aListeners.end();
     311             :                 ++loop
     312             :             )
     313             :         {
     314           0 :             (*loop)->allColumnsRemoved();
     315           0 :         }
     316             :     }
     317             : 
     318             : 
     319           0 :     void UnoControlTableModel::impl_notifyTableMetricsChanged() const
     320             :     {
     321           0 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     322           0 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     323           0 :                 loop != aListeners.end();
     324             :                 ++loop
     325             :             )
     326             :         {
     327           0 :             (*loop)->tableMetricsChanged();
     328           0 :         }
     329           0 :     }
     330             : 
     331             : 
     332           2 :     PTableRenderer UnoControlTableModel::getRenderer() const
     333             :     {
     334             :         DBG_CHECK_ME();
     335           2 :         return m_pImpl->pRenderer;
     336             :     }
     337             : 
     338             : 
     339           2 :     PTableInputHandler UnoControlTableModel::getInputHandler() const
     340             :     {
     341             :         DBG_CHECK_ME();
     342           2 :         return m_pImpl->pInputHandler;
     343             :     }
     344             : 
     345             : 
     346           2 :     TableMetrics UnoControlTableModel::getRowHeight() const
     347             :     {
     348             :         DBG_CHECK_ME();
     349           2 :         return m_pImpl->nRowHeight;
     350             :     }
     351             : 
     352             : 
     353           2 :     void UnoControlTableModel::setRowHeight(TableMetrics _nRowHeight)
     354             :     {
     355             :         DBG_CHECK_ME();
     356           2 :         if ( m_pImpl->nRowHeight == _nRowHeight )
     357           4 :             return;
     358             : 
     359           0 :         m_pImpl->nRowHeight = _nRowHeight;
     360           0 :         impl_notifyTableMetricsChanged();
     361             :     }
     362             : 
     363             : 
     364           2 :     TableMetrics UnoControlTableModel::getColumnHeaderHeight() const
     365             :     {
     366             :         DBG_CHECK_ME();
     367             :         DBG_ASSERT( hasColumnHeaders(), "DefaultTableModel::getColumnHeaderHeight: invalid call!" );
     368           2 :         return m_pImpl->nColumnHeaderHeight;
     369             :     }
     370             : 
     371             : 
     372           0 :     TableMetrics UnoControlTableModel::getRowHeaderWidth() const
     373             :     {
     374             :         DBG_CHECK_ME();
     375             :         DBG_ASSERT( hasRowHeaders(), "DefaultTableModel::getRowHeaderWidth: invalid call!" );
     376           0 :         return m_pImpl->nRowHeaderWidth;
     377             :     }
     378             : 
     379           2 :     void UnoControlTableModel::setColumnHeaderHeight(TableMetrics _nHeight)
     380             :     {
     381             :         DBG_CHECK_ME();
     382           2 :         if ( m_pImpl->nColumnHeaderHeight == _nHeight )
     383           4 :             return;
     384             : 
     385           0 :         m_pImpl->nColumnHeaderHeight = _nHeight;
     386           0 :         impl_notifyTableMetricsChanged();
     387             :     }
     388             : 
     389             : 
     390           2 :     void UnoControlTableModel::setRowHeaderWidth(TableMetrics _nWidth)
     391             :     {
     392             :         DBG_CHECK_ME();
     393           2 :         if ( m_pImpl->nRowHeaderWidth == _nWidth )
     394           4 :             return;
     395             : 
     396           0 :         m_pImpl->nRowHeaderWidth = _nWidth;
     397           0 :         impl_notifyTableMetricsChanged();
     398             :     }
     399             : 
     400             : 
     401          40 :     ScrollbarVisibility UnoControlTableModel::getVerticalScrollbarVisibility() const
     402             :     {
     403             :         DBG_CHECK_ME();
     404          40 :         return m_pImpl->eVScrollMode;
     405             :     }
     406             : 
     407             : 
     408          20 :     ScrollbarVisibility UnoControlTableModel::getHorizontalScrollbarVisibility() const
     409             :     {
     410             :         DBG_CHECK_ME();
     411          20 :         return m_pImpl->eHScrollMode;
     412             :     }
     413             : 
     414             : 
     415           2 :     void UnoControlTableModel::addTableModelListener( const PTableModelListener& i_listener )
     416             :     {
     417             :         DBG_CHECK_ME();
     418           4 :         ENSURE_OR_RETURN_VOID( !!i_listener, "illegal NULL listener" );
     419           2 :         m_pImpl->m_aListeners.push_back( i_listener );
     420             :     }
     421             : 
     422             : 
     423           2 :     void UnoControlTableModel::removeTableModelListener( const PTableModelListener& i_listener )
     424             :     {
     425             :         DBG_CHECK_ME();
     426           6 :         for (   ModellListeners::iterator lookup = m_pImpl->m_aListeners.begin();
     427           4 :                 lookup != m_pImpl->m_aListeners.end();
     428             :                 ++lookup
     429             :             )
     430             :         {
     431           2 :             if ( *lookup == i_listener )
     432             :             {
     433           2 :                 m_pImpl->m_aListeners.erase( lookup );
     434           4 :                 return;
     435             :             }
     436             :         }
     437             :         OSL_ENSURE( false, "UnoControlTableModel::removeTableModelListener: listener is not registered - sure you're doing the right thing here?" );
     438             :     }
     439             : 
     440             : 
     441           2 :     void UnoControlTableModel::setVerticalScrollbarVisibility( ScrollbarVisibility const i_visibility ) const
     442             :     {
     443             :         DBG_CHECK_ME();
     444           2 :         m_pImpl->eVScrollMode = i_visibility;
     445           2 :     }
     446             : 
     447             : 
     448           2 :     void UnoControlTableModel::setHorizontalScrollbarVisibility( ScrollbarVisibility const i_visibility ) const
     449             :     {
     450             :         DBG_CHECK_ME();
     451           2 :         m_pImpl->eHScrollMode = i_visibility;
     452           2 :     }
     453             : 
     454             : 
     455           2 :     void UnoControlTableModel::setDataModel( Reference< XGridDataModel > const & i_gridDataModel )
     456             :     {
     457             :         DBG_CHECK_ME();
     458           2 :         m_pImpl->m_aDataModel = i_gridDataModel;
     459             :         // TODO: register as listener, so we're notified of row/data changes, and can multiplex them to our
     460             :         // own listeners
     461           2 :     }
     462             : 
     463             : 
     464           6 :     Reference< XGridDataModel > UnoControlTableModel::getDataModel() const
     465             :     {
     466           6 :         Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
     467           6 :         return xDataModel;
     468             :     }
     469             : 
     470             : 
     471           4 :     bool UnoControlTableModel::hasDataModel() const
     472             :     {
     473           4 :         return getDataModel().is();
     474             :     }
     475             : 
     476             : 
     477           2 :     void UnoControlTableModel::setColumnModel( Reference< XGridColumnModel > const & i_gridColumnModel )
     478             :     {
     479             :         DBG_CHECK_ME();
     480           2 :         m_pImpl->m_aColumnModel = i_gridColumnModel;
     481           2 :     }
     482             : 
     483             : 
     484          10 :     Reference< XGridColumnModel > UnoControlTableModel::getColumnModel() const
     485             :     {
     486          10 :         Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel );
     487          10 :         return xColumnModel;
     488             :     }
     489             : 
     490             : 
     491           6 :     bool UnoControlTableModel::hasColumnModel() const
     492             :     {
     493           6 :         return getColumnModel().is();
     494             :     }
     495             : 
     496             : 
     497           0 :     void UnoControlTableModel::getCellContent( ColPos const i_col, RowPos const i_row, Any& o_cellContent )
     498             :     {
     499             :         DBG_CHECK_ME();
     500             : 
     501           0 :         o_cellContent.clear();
     502             :         try
     503             :         {
     504           0 :             Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
     505           0 :             ENSURE_OR_RETURN_VOID( xDataModel.is(), "UnoControlTableModel::getCellContent: no data model anymore!" );
     506             : 
     507           0 :             PColumnModel const pColumn = getColumnModel( i_col );
     508           0 :             UnoGridColumnFacade* pColumnImpl = dynamic_cast< UnoGridColumnFacade* >( pColumn.get() );
     509           0 :             ENSURE_OR_RETURN_VOID( pColumnImpl != NULL, "UnoControlTableModel::getCellContent: no (valid) column at this position!" );
     510           0 :             sal_Int32 const nDataColumnIndex = pColumnImpl->getDataColumnIndex() >= 0 ? pColumnImpl->getDataColumnIndex() : i_col;
     511             : 
     512           0 :             if ( nDataColumnIndex >= xDataModel->getColumnCount() )
     513             :             {
     514             :                 // this is allowed, in case the column model has been dynamically extended, but the data model does
     515             :                 // not (yet?) know about it.
     516             :                 // So, handle it gracefully.
     517             :             #if OSL_DEBUG_LEVEL > 0
     518             :                 {
     519             :                     Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel );
     520             :                     OSL_ENSURE( xColumnModel.is() && i_col < xColumnModel->getColumnCount(),
     521             :                         "UnoControlTableModel::getCellContent: request a column's value which the ColumnModel doesn't know about!" );
     522             :                 }
     523             :             #endif
     524             :             }
     525             :             else
     526             :             {
     527           0 :                 o_cellContent = xDataModel->getCellData( nDataColumnIndex, i_row );
     528           0 :             }
     529             :         }
     530           0 :         catch( const Exception& )
     531             :         {
     532             :             DBG_UNHANDLED_EXCEPTION();
     533             :         }
     534             :     }
     535             : 
     536             : 
     537           0 :     void UnoControlTableModel::getCellToolTip( ColPos const i_col, RowPos const i_row, Any& o_cellToolTip )
     538             :     {
     539             :         DBG_CHECK_ME();
     540             :         try
     541             :         {
     542           0 :             Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
     543           0 :             ENSURE_OR_THROW( xDataModel.is(), "no data model anymore!" );
     544             : 
     545           0 :             o_cellToolTip = xDataModel->getCellToolTip( i_col, i_row );
     546             :         }
     547           0 :         catch( const Exception& )
     548             :         {
     549             :             DBG_UNHANDLED_EXCEPTION();
     550             :         }
     551           0 :     }
     552             : 
     553             : 
     554           0 :     Any UnoControlTableModel::getRowHeading( RowPos const i_rowPos ) const
     555             :     {
     556             :         DBG_CHECK_ME();
     557             : 
     558           0 :         Any aRowHeading;
     559             : 
     560           0 :         Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
     561           0 :         ENSURE_OR_RETURN( xDataModel.is(), "UnoControlTableModel::getRowHeading: no data model anymore!", aRowHeading );
     562             : 
     563             :         try
     564             :         {
     565           0 :             aRowHeading = xDataModel->getRowHeading( i_rowPos );
     566             :         }
     567           0 :         catch( const Exception& )
     568             :         {
     569             :             DBG_UNHANDLED_EXCEPTION();
     570             :         }
     571           0 :         return aRowHeading;
     572             :     }
     573             : 
     574             : 
     575             :     namespace
     576             :     {
     577          18 :         void lcl_setColor( Any const & i_color, ::boost::optional< ::Color > & o_convertedColor )
     578             :         {
     579          18 :             if ( !i_color.hasValue() )
     580          18 :                 o_convertedColor.reset();
     581             :             else
     582             :             {
     583           0 :                 sal_Int32 nColor = COL_TRANSPARENT;
     584           0 :                 if ( i_color >>= nColor )
     585             :                 {
     586           0 :                     o_convertedColor.reset( ::Color( nColor ) );
     587             :                 }
     588             :                 else
     589             :                 {
     590             :                     OSL_ENSURE( false, "lcl_setColor: could not extract color value!" );
     591             :                 }
     592             :             }
     593          18 :         }
     594             :     }
     595             : 
     596             : 
     597           0 :     ::boost::optional< ::Color > UnoControlTableModel::getLineColor() const
     598             :     {
     599             :         DBG_CHECK_ME();
     600           0 :         return m_pImpl->m_aGridLineColor;
     601             :     }
     602             : 
     603             : 
     604           2 :     void UnoControlTableModel::setLineColor( Any const & i_color )
     605             :     {
     606             :         DBG_CHECK_ME();
     607           2 :         lcl_setColor( i_color, m_pImpl->m_aGridLineColor );
     608           2 :     }
     609             : 
     610             : 
     611           0 :     ::boost::optional< ::Color > UnoControlTableModel::getHeaderBackgroundColor() const
     612             :     {
     613             :         DBG_CHECK_ME();
     614           0 :         return m_pImpl->m_aHeaderBackgroundColor;
     615             :     }
     616             : 
     617             : 
     618           2 :     void UnoControlTableModel::setHeaderBackgroundColor( Any const & i_color )
     619             :     {
     620             :         DBG_CHECK_ME();
     621           2 :         lcl_setColor( i_color, m_pImpl->m_aHeaderBackgroundColor );
     622           2 :     }
     623             : 
     624             : 
     625           0 :     ::boost::optional< ::Color > UnoControlTableModel::getHeaderTextColor() const
     626             :     {
     627             :         DBG_CHECK_ME();
     628           0 :         return m_pImpl->m_aHeaderTextColor;
     629             :     }
     630             : 
     631             : 
     632           0 :     ::boost::optional< ::Color > UnoControlTableModel::getActiveSelectionBackColor() const
     633             :     {
     634             :         DBG_CHECK_ME();
     635           0 :         return m_pImpl->m_aActiveSelectionBackColor;
     636             :     }
     637             : 
     638             : 
     639           0 :     ::boost::optional< ::Color > UnoControlTableModel::getInactiveSelectionBackColor() const
     640             :     {
     641             :         DBG_CHECK_ME();
     642           0 :         return m_pImpl->m_aInactiveSelectionBackColor;
     643             :     }
     644             : 
     645             : 
     646           0 :     ::boost::optional< ::Color > UnoControlTableModel::getActiveSelectionTextColor() const
     647             :     {
     648             :         DBG_CHECK_ME();
     649           0 :         return m_pImpl->m_aActiveSelectionTextColor;
     650             :     }
     651             : 
     652             : 
     653           0 :     ::boost::optional< ::Color > UnoControlTableModel::getInactiveSelectionTextColor() const
     654             :     {
     655             :         DBG_CHECK_ME();
     656           0 :         return m_pImpl->m_aInactiveSelectionTextColor;
     657             :     }
     658             : 
     659             : 
     660           2 :     void UnoControlTableModel::setHeaderTextColor( Any const & i_color )
     661             :     {
     662             :         DBG_CHECK_ME();
     663           2 :         lcl_setColor( i_color, m_pImpl->m_aHeaderTextColor );
     664           2 :     }
     665             : 
     666             : 
     667           2 :     void UnoControlTableModel::setActiveSelectionBackColor( Any const & i_color )
     668             :     {
     669             :         DBG_CHECK_ME();
     670           2 :         lcl_setColor( i_color, m_pImpl->m_aActiveSelectionBackColor );
     671           2 :     }
     672             : 
     673             : 
     674           2 :     void UnoControlTableModel::setInactiveSelectionBackColor( Any const & i_color )
     675             :     {
     676             :         DBG_CHECK_ME();
     677           2 :         lcl_setColor( i_color, m_pImpl->m_aInactiveSelectionBackColor );
     678           2 :     }
     679             : 
     680             : 
     681           2 :     void UnoControlTableModel::setActiveSelectionTextColor( Any const & i_color )
     682             :     {
     683             :         DBG_CHECK_ME();
     684           2 :         lcl_setColor( i_color, m_pImpl->m_aActiveSelectionTextColor );
     685           2 :     }
     686             : 
     687             : 
     688           2 :     void UnoControlTableModel::setInactiveSelectionTextColor( Any const & i_color )
     689             :     {
     690             :         DBG_CHECK_ME();
     691           2 :         lcl_setColor( i_color, m_pImpl->m_aInactiveSelectionTextColor );
     692           2 :     }
     693             : 
     694             : 
     695           0 :     ::boost::optional< ::Color > UnoControlTableModel::getTextColor() const
     696             :     {
     697             :         DBG_CHECK_ME();
     698           0 :         return m_pImpl->m_aTextColor;
     699             :     }
     700             : 
     701             : 
     702           2 :     void UnoControlTableModel::setTextColor( Any const & i_color )
     703             :     {
     704             :         DBG_CHECK_ME();
     705           2 :         lcl_setColor( i_color, m_pImpl->m_aTextColor );
     706           2 :     }
     707             : 
     708             : 
     709           0 :     ::boost::optional< ::Color > UnoControlTableModel::getTextLineColor() const
     710             :     {
     711             :         DBG_CHECK_ME();
     712           0 :         return m_pImpl->m_aTextColor;
     713             :     }
     714             : 
     715             : 
     716           2 :     void UnoControlTableModel::setTextLineColor( Any const & i_color )
     717             :     {
     718             :         DBG_CHECK_ME();
     719           2 :         lcl_setColor( i_color, m_pImpl->m_aTextLineColor );
     720           2 :     }
     721             : 
     722             : 
     723           0 :     ::boost::optional< ::std::vector< ::Color > > UnoControlTableModel::getRowBackgroundColors() const
     724             :     {
     725             :         DBG_CHECK_ME();
     726           0 :         return m_pImpl->m_aRowColors;
     727             :     }
     728             : 
     729             : 
     730           2 :     void UnoControlTableModel::setRowBackgroundColors( ::com::sun::star::uno::Any const & i_APIValue )
     731             :     {
     732             :         DBG_CHECK_ME();
     733           2 :         Sequence< ::com::sun::star::util::Color > aAPIColors;
     734           2 :         if ( !( i_APIValue >>= aAPIColors ) )
     735           2 :             m_pImpl->m_aRowColors.reset();
     736             :         else
     737             :         {
     738           0 :             ::std::vector< ::Color > aColors( aAPIColors.getLength() );
     739           0 :             for ( sal_Int32 i=0; i<aAPIColors.getLength(); ++i )
     740             :             {
     741           0 :                 aColors[i] = ::Color( aAPIColors[i] );
     742             :             }
     743           0 :             m_pImpl->m_aRowColors.reset( aColors );
     744           2 :         }
     745           2 :     }
     746             : 
     747             : 
     748           0 :     VerticalAlignment UnoControlTableModel::getVerticalAlign() const
     749             :     {
     750             :         DBG_CHECK_ME();
     751           0 :         return  m_pImpl->m_eVerticalAlign;
     752             :     }
     753             : 
     754             : 
     755           0 :     void UnoControlTableModel::setVerticalAlign( VerticalAlignment _xAlign )
     756             :     {
     757             :         DBG_CHECK_ME();
     758           0 :         m_pImpl->m_eVerticalAlign = _xAlign;
     759           0 :     }
     760             : 
     761             : 
     762          16 :     ColPos UnoControlTableModel::getColumnPos( UnoGridColumnFacade const & i_column ) const
     763             :     {
     764             :         DBG_CHECK_ME();
     765          78 :         for (   ColumnModels::const_iterator col = m_pImpl->aColumns.begin();
     766          52 :                 col != m_pImpl->aColumns.end();
     767             :                 ++col
     768             :             )
     769             :         {
     770          26 :             if ( &i_column == col->get() )
     771          16 :                 return col - m_pImpl->aColumns.begin();
     772             :         }
     773             :         OSL_ENSURE( false, "UnoControlTableModel::getColumnPos: column not found!" );
     774           0 :         return COL_INVALID;
     775             :     }
     776             : 
     777             : 
     778           0 :     ITableDataSort* UnoControlTableModel::getSortAdapter()
     779             :     {
     780             :         DBG_CHECK_ME();
     781             : 
     782           0 :         Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY );
     783           0 :         if ( xSortAccess.is() )
     784           0 :             return this;
     785           0 :         return NULL;
     786             :     }
     787             : 
     788             : 
     789           0 :     bool UnoControlTableModel::isEnabled() const
     790             :     {
     791             :         DBG_CHECK_ME();
     792           0 :         return m_pImpl->bEnabled;
     793             :     }
     794             : 
     795             : 
     796           2 :     void UnoControlTableModel::setEnabled( bool _bEnabled )
     797             :     {
     798             :         DBG_CHECK_ME();
     799           2 :         m_pImpl->bEnabled = _bEnabled;
     800           2 :     }
     801             : 
     802             : 
     803           0 :     void UnoControlTableModel::sortByColumn( ColPos const i_column, ColumnSortDirection const i_sortDirection )
     804             :     {
     805             :         DBG_CHECK_ME();
     806             : 
     807             :         try
     808             :         {
     809           0 :             Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY_THROW );
     810           0 :             xSortAccess->sortByColumn( i_column, i_sortDirection == ColumnSortAscending );
     811             :         }
     812           0 :         catch( const Exception& )
     813             :         {
     814             :             DBG_UNHANDLED_EXCEPTION();
     815             :         }
     816           0 :     }
     817             : 
     818             : 
     819           0 :     ColumnSort UnoControlTableModel::getCurrentSortOrder() const
     820             :     {
     821             :         DBG_CHECK_ME();
     822             : 
     823           0 :         ColumnSort currentSort;
     824             :         try
     825             :         {
     826           0 :             Reference< XSortableGridData > const xSortAccess( getDataModel(), UNO_QUERY_THROW );
     827           0 :             Pair< ::sal_Int32, sal_Bool > const aCurrentSortOrder( xSortAccess->getCurrentSortOrder() );
     828           0 :             currentSort.nColumnPos = aCurrentSortOrder.First;
     829           0 :             currentSort.eSortDirection = aCurrentSortOrder.Second ? ColumnSortAscending : ColumnSortDescending;
     830             :         }
     831           0 :         catch( const Exception& )
     832             :         {
     833             :             DBG_UNHANDLED_EXCEPTION();
     834             :         }
     835           0 :         return currentSort;
     836             :     }
     837             : 
     838             : 
     839          16 :     void UnoControlTableModel::notifyColumnChange( ColPos const i_columnPos, ColumnAttributeGroup const i_attributeGroup ) const
     840             :     {
     841             :         DBG_CHECK_ME();
     842          32 :         ENSURE_OR_RETURN_VOID( ( i_columnPos >= 0 ) && ( i_columnPos < getColumnCount() ),
     843             :             "UnoControlTableModel::notifyColumnChange: invalid column index!" );
     844             : 
     845          16 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     846          96 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     847          64 :                 loop != aListeners.end();
     848             :                 ++loop
     849             :             )
     850             :         {
     851          16 :             (*loop)->columnChanged( i_columnPos, i_attributeGroup );
     852          16 :         }
     853             :     }
     854             : 
     855             : 
     856           4 :     void UnoControlTableModel::notifyRowsInserted( GridDataEvent const & i_event ) const
     857             :     {
     858             :         // check sanity of the event
     859           4 :         ENSURE_OR_RETURN_VOID( i_event.FirstRow >= 0, "UnoControlTableModel::notifyRowsInserted: invalid first row!" );
     860           4 :         ENSURE_OR_RETURN_VOID( i_event.LastRow >= i_event.FirstRow, "UnoControlTableModel::notifyRowsInserted: invalid row indexes!" );
     861             : 
     862             :         // check own sanity
     863           4 :         Reference< XGridColumnModel > const xColumnModel( m_pImpl->m_aColumnModel );
     864           4 :         ENSURE_OR_RETURN_VOID( xColumnModel.is(), "UnoControlTableModel::notifyRowsInserted: no column model anymore!" );
     865             : 
     866           8 :         Reference< XGridDataModel > const xDataModel( m_pImpl->m_aDataModel );
     867           4 :         ENSURE_OR_RETURN_VOID( xDataModel.is(), "UnoControlTableModel::notifyRowsInserted: no data model anymore!" );
     868             : 
     869             :         // implicitly add columns to the column model
     870             :         // TODO: is this really a good idea?
     871           4 :         sal_Int32 const dataColumnCount = xDataModel->getColumnCount();
     872             :         OSL_ENSURE( dataColumnCount > 0, "UnoControlTableModel::notifyRowsInserted: no columns at all?" );
     873             : 
     874           4 :         sal_Int32 const modelColumnCount = xColumnModel->getColumnCount();
     875           4 :         if ( ( modelColumnCount == 0 ) && ( dataColumnCount > 0 ) )
     876             :         {
     877             :             // TODO: shouldn't we clear the mutexes guard for this call?
     878           2 :             xColumnModel->setDefaultColumns( dataColumnCount );
     879             :         }
     880             : 
     881             :         // multiplex the event to our own listeners
     882           8 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     883          24 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     884          16 :                 loop != aListeners.end();
     885             :                 ++loop
     886             :             )
     887             :         {
     888           4 :             (*loop)->rowsInserted( i_event.FirstRow, i_event.LastRow );
     889           4 :         }
     890             :     }
     891             : 
     892             : 
     893           2 :     void UnoControlTableModel::notifyRowsRemoved( GridDataEvent const & i_event ) const
     894             :     {
     895           2 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     896          12 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     897           8 :                 loop != aListeners.end();
     898             :                 ++loop
     899             :             )
     900             :         {
     901           2 :             (*loop)->rowsRemoved( i_event.FirstRow, i_event.LastRow );
     902           2 :         }
     903           2 :     }
     904             : 
     905             : 
     906           0 :     void UnoControlTableModel::notifyDataChanged( ::com::sun::star::awt::grid::GridDataEvent const & i_event ) const
     907             :     {
     908           0 :         ColPos const firstCol = i_event.FirstColumn == -1 ? 0 : i_event.FirstColumn;
     909           0 :         ColPos const lastCol = i_event.FirstColumn == -1 ? getColumnCount() - 1 : i_event.LastColumn;
     910           0 :         RowPos const firstRow = i_event.FirstRow == -1 ? 0 : i_event.FirstRow;
     911           0 :         RowPos const lastRow = i_event.FirstRow == -1 ? getRowCount() - 1 : i_event.LastRow;
     912             : 
     913           0 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     914           0 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     915           0 :                 loop != aListeners.end();
     916             :                 ++loop
     917             :             )
     918             :         {
     919           0 :             (*loop)->cellsUpdated( firstCol, lastCol, firstRow, lastRow );
     920           0 :         }
     921           0 :     }
     922             : 
     923             : 
     924           0 :     void UnoControlTableModel::notifyAllDataChanged() const
     925             :     {
     926           0 :         ModellListeners aListeners( m_pImpl->m_aListeners );
     927           0 :         for (   ModellListeners::const_iterator loop = aListeners.begin();
     928           0 :                 loop != aListeners.end();
     929             :                 ++loop
     930             :             )
     931             :         {
     932           0 :             (*loop)->cellsUpdated( 0, getColumnCount() - 1, 0, getRowCount() - 1 );
     933           0 :         }
     934           0 :     }
     935             : 
     936             : 
     937        1227 : } } // svt::table
     938             : 
     939             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10