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