svtools/source/uno/unocontroltablemodel.cxx

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