svtools/source/uno/svtxgridcontrol.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 "svtxgridcontrol.hxx"
  21 #include <com/sun/star/view/SelectionType.hpp>
  22 #include "table/tablecontrolinterface.hxx"
  23 #include "table/gridtablerenderer.hxx"
  24 #include "table/tablecontrol.hxx"
  25 #include "unocontroltablemodel.hxx"
  26 #include <comphelper/sequence.hxx>
  27 #include <rtl/ref.hxx>
  28 #include <tools/diagnose_ex.h>
  29 #include <toolkit/helper/property.hxx>
  30 #include <toolkit/helper/vclunohelper.hxx>
  31 #include <comphelper/processfactory.hxx>
  32 #include <com/sun/star/awt/grid/XGridColumn.hpp>
  33 #include <com/sun/star/awt/XControl.hpp>
  34 #include <com/sun/star/awt/grid/GridInvalidDataException.hpp>
  35 #include <com/sun/star/awt/grid/GridInvalidModelException.hpp>
  36 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  37 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  38 #include <com/sun/star/util/Color.hpp>
  39 #include <com/sun/star/awt/FontDescriptor.hpp>
  40
  41 #include <vcl/svapp.hxx>
  42
  43 using ::com::sun::star::uno::RuntimeException;
  44 using ::com::sun::star::uno::Reference;
  45 using ::com::sun::star::uno::Exception;
  46 using ::com::sun::star::uno::UNO_QUERY;
  47 using ::com::sun::star::uno::UNO_QUERY_THROW;
  48 using ::com::sun::star::uno::Any;
  49 using ::com::sun::star::uno::makeAny;
  50 using ::com::sun::star::uno::Sequence;
  51 using ::com::sun::star::awt::grid::XGridSelectionListener;
  52 using ::com::sun::star::style::VerticalAlignment;
  53 using ::com::sun::star::style::VerticalAlignment_TOP;
  54 using ::com::sun::star::view::SelectionType;
  55 using ::com::sun::star::view::SelectionType_NONE;
  56 using ::com::sun::star::view::SelectionType_RANGE;
  57 using ::com::sun::star::view::SelectionType_SINGLE;
  58 using ::com::sun::star::view::SelectionType_MULTI;
  59 using ::com::sun::star::awt::grid::XGridDataModel;
  60 using ::com::sun::star::awt::grid::GridInvalidDataException;
  61 using ::com::sun::star::lang::EventObject;
  62 using ::com::sun::star::lang::IndexOutOfBoundsException;
  63 using ::com::sun::star::awt::grid::XGridColumnModel;
  64 using ::com::sun::star::awt::grid::GridSelectionEvent;
  65 using ::com::sun::star::awt::grid::XGridColumn;
  66 using ::com::sun::star::container::ContainerEvent;
  67 using ::com::sun::star::awt::grid::GridDataEvent;
  68 using ::com::sun::star::awt::grid::GridInvalidModelException;
  69 using ::com::sun::star::util::VetoException;
  70
  71 namespace AccessibleEventId = ::com::sun::star::accessibility::AccessibleEventId;
  72 namespace AccessibleStateType = ::com::sun::star::accessibility::AccessibleStateType;
  73
  74 using namespace ::svt::table;
  75
  76 typedef ::com::sun::star::util::Color   UnoColor;
  77
  78
  79 SVTXGridControl::SVTXGridControl()
  80     :m_xTableModel( new UnoControlTableModel() )
  81     ,m_bTableModelInitCompleted( false )
  82     ,m_aSelectionListeners( *this )
  83 {
  84 }
  85
  86
  87 SVTXGridControl::~SVTXGridControl()
  88 {
  89 }
  90
  91
  92 void SVTXGridControl::SetWindow( const VclPtr< vcl::Window > &pWindow )
  93 {
  94     SVTXGridControl_Base::SetWindow( pWindow );
  95     impl_checkTableModelInit();
  96 }
  97
  98
  99 void SVTXGridControl::impl_checkColumnIndex_throw( ::svt::table::TableControl const & i_table, sal_Int32 const i_columnIndex ) const
 100 {
 101     if ( ( i_columnIndex < 0 ) || ( i_columnIndex >= i_table.GetColumnCount() ) )
 102         throw IndexOutOfBoundsException( OUString(), *const_cast< SVTXGridControl* >( this ) );
 103 }
 104
 105
 106 void SVTXGridControl::impl_checkRowIndex_throw( ::svt::table::TableControl const & i_table, sal_Int32 const i_rowIndex ) const
 107 {
 108     if ( ( i_rowIndex < 0 ) || ( i_rowIndex >= i_table.GetRowCount() ) )
 109         throw IndexOutOfBoundsException( OUString(), *const_cast< SVTXGridControl* >( this ) );
 110 }
 111
 112
 113 sal_Int32 SAL_CALL SVTXGridControl::getRowAtPoint(::sal_Int32 x, ::sal_Int32 y) throw (RuntimeException, std::exception)
 114 {
 115     SolarMutexGuard aGuard;
 116
 117     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 118     ENSURE_OR_RETURN( pTable, "SVTXGridControl::getRowAtPoint: no control (anymore)!", -1 );
 119
 120     TableCell const tableCell = pTable->getTableControlInterface().hitTest( Point( x, y ) );
 121     return ( tableCell.nRow >= 0 ) ? tableCell.nRow : -1;
 122 }
 123
 124
 125 sal_Int32 SAL_CALL SVTXGridControl::getColumnAtPoint(::sal_Int32 x, ::sal_Int32 y) throw (RuntimeException, std::exception)
 126 {
 127     SolarMutexGuard aGuard;
 128
 129     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 130     ENSURE_OR_RETURN( pTable, "SVTXGridControl::getColumnAtPoint: no control (anymore)!", -1 );
 131
 132     TableCell const tableCell = pTable->getTableControlInterface().hitTest( Point( x, y ) );
 133     return ( tableCell.nColumn >= 0 ) ? tableCell.nColumn : -1;
 134 }
 135
 136
 137 sal_Int32 SAL_CALL SVTXGridControl::getCurrentColumn(  ) throw (RuntimeException, std::exception)
 138 {
 139     SolarMutexGuard aGuard;
 140
 141     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 142     ENSURE_OR_RETURN( pTable, "SVTXGridControl::getCurrentColumn: no control (anymore)!", -1 );
 143
 144     sal_Int32 const nColumn = pTable->GetCurrentColumn();
 145     return ( nColumn >= 0 ) ? nColumn : -1;
 146 }
 147
 148
 149 sal_Int32 SAL_CALL SVTXGridControl::getCurrentRow(  ) throw (RuntimeException, std::exception)
 150 {
 151     SolarMutexGuard aGuard;
 152
 153     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 154     ENSURE_OR_RETURN( pTable, "SVTXGridControl::getCurrentRow: no control (anymore)!", -1 );
 155
 156     sal_Int32 const nRow = pTable->GetCurrentRow();
 157     return ( nRow >= 0 ) ? nRow : -1;
 158 }
 159
 160
 161 void SAL_CALL SVTXGridControl::goToCell( ::sal_Int32 i_columnIndex, ::sal_Int32 i_rowIndex ) throw (RuntimeException, IndexOutOfBoundsException, VetoException, std::exception)
 162 {
 163     SolarMutexGuard aGuard;
 164
 165     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 166     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::getCurrentRow: no control (anymore)!" );
 167
 168     impl_checkColumnIndex_throw( *pTable, i_columnIndex );
 169     impl_checkRowIndex_throw( *pTable, i_rowIndex );
 170
 171     pTable->GoTo( i_columnIndex, i_rowIndex );
 172 }
 173
 174
 175 void SAL_CALL SVTXGridControl::addSelectionListener(const Reference< XGridSelectionListener > & listener) throw (RuntimeException, std::exception)
 176 {
 177     m_aSelectionListeners.addInterface(listener);
 178 }
 179
 180
 181 void SAL_CALL SVTXGridControl::removeSelectionListener(const Reference< XGridSelectionListener > & listener) throw (RuntimeException, std::exception)
 182 {
 183     m_aSelectionListeners.removeInterface(listener);
 184 }
 185
 186
 187 void SVTXGridControl::setProperty( const OUString& PropertyName, const Any& aValue) throw(RuntimeException, std::exception)
 188 {
 189     SolarMutexGuard aGuard;
 190
 191     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 192     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::setProperty: no control (anymore)!" );
 193
 194     switch( GetPropertyId( PropertyName ) )
 195     {
 196         case BASEPROPERTY_ROW_HEADER_WIDTH:
 197         {
 198             sal_Int32 rowHeaderWidth( -1 );
 199             aValue >>= rowHeaderWidth;
 200             if ( rowHeaderWidth <= 0 )
 201             {
 202                 SAL_WARN( "svtools.uno", "SVTXGridControl::setProperty: illegal row header width!" );
 203                 break;
 204             }
 205
 206             m_xTableModel->setRowHeaderWidth( rowHeaderWidth );
 207             // TODO: the model should broadcast this change itself, and the table should invalidate itself as needed
 208             pTable->Invalidate();
 209         }
 210         break;
 211
 212         case BASEPROPERTY_COLUMN_HEADER_HEIGHT:
 213         {
 214             sal_Int32 columnHeaderHeight = 0;
 215             if ( !aValue.hasValue() )
 216             {
 217                 columnHeaderHeight = pTable->PixelToLogic( Size( 0, pTable->GetTextHeight() + 3 ), MAP_APPFONT ).Height();
 218             }
 219             else
 220             {
 221                 aValue >>= columnHeaderHeight;
 222             }
 223             if ( columnHeaderHeight <= 0 )
 224             {
 225                 SAL_WARN( "svtools.uno", "SVTXGridControl::setProperty: illegal column header width!" );
 226                 break;
 227             }
 228
 229             m_xTableModel->setColumnHeaderHeight( columnHeaderHeight );
 230             // TODO: the model should broadcast this change itself, and the table should invalidate itself as needed
 231             pTable->Invalidate();
 232         }
 233         break;
 234
 235         case BASEPROPERTY_USE_GRID_LINES:
 236         {
 237             GridTableRenderer* pGridRenderer = dynamic_cast< GridTableRenderer* >(
 238                 m_xTableModel->getRenderer().get() );
 239             if ( !pGridRenderer )
 240             {
 241                 SAL_WARN( "svtools.uno", "SVTXGridControl::setProperty(UseGridLines): invalid renderer!" );
 242                 break;
 243             }
 244
 245             bool bUseGridLines = false;
 246             OSL_VERIFY( aValue >>= bUseGridLines );
 247             pGridRenderer->useGridLines( bUseGridLines );
 248             pTable->Invalidate();
 249         }
 250         break;
 251
 252         case BASEPROPERTY_ROW_HEIGHT:
 253         {
 254             sal_Int32 rowHeight = 0;
 255             if ( !aValue.hasValue() )
 256             {
 257                 rowHeight = pTable->PixelToLogic( Size( 0, pTable->GetTextHeight() + 3 ), MAP_APPFONT ).Height();
 258             }
 259             else
 260             {
 261                 aValue >>= rowHeight;
 262             }
 263             m_xTableModel->setRowHeight( rowHeight );
 264             if ( rowHeight <= 0 )
 265             {
 266                 SAL_WARN( "svtools.uno", "SVTXGridControl::setProperty: illegal row height!" );
 267                 break;
 268             }
 269
 270             // TODO: the model should broadcast this change itself, and the table should invalidate itself as needed
 271             pTable->Invalidate();
 272         }
 273         break;
 274
 275         case BASEPROPERTY_BACKGROUNDCOLOR:
 276         {
 277             // let the base class handle this for the TableControl
 278             VCLXWindow::setProperty( PropertyName, aValue );
 279             // and forward to the grid control's data window
 280             if ( pTable->IsBackground() )
 281                 pTable->getDataWindow().SetBackground( pTable->GetBackground() );
 282             else
 283                 pTable->getDataWindow().SetBackground();
 284         }
 285         break;
 286
 287         case BASEPROPERTY_GRID_SELECTIONMODE:
 288         {
 289             SelectionType eSelectionType;
 290             if( aValue >>= eSelectionType )
 291             {
 292                 SelectionMode eSelMode;
 293                 switch( eSelectionType )
 294                 {
 295                 case SelectionType_SINGLE:  eSelMode = SINGLE_SELECTION; break;
 296                 case SelectionType_RANGE:   eSelMode = RANGE_SELECTION; break;
 297                 case SelectionType_MULTI:   eSelMode = MULTIPLE_SELECTION; break;
 298                 default:                    eSelMode = NO_SELECTION; break;
 299                 }
 300                 if( pTable->getSelEngine()->GetSelectionMode() != eSelMode )
 301                     pTable->getSelEngine()->SetSelectionMode( eSelMode );
 302             }
 303             break;
 304         }
 305         case BASEPROPERTY_HSCROLL:
 306         {
 307             bool bHScroll = true;
 308             if( aValue >>= bHScroll )
 309                 m_xTableModel->setHorizontalScrollbarVisibility( bHScroll ? ScrollbarShowAlways : ScrollbarShowSmart );
 310             break;
 311         }
 312
 313         case BASEPROPERTY_VSCROLL:
 314         {
 315             bool bVScroll = true;
 316             if( aValue >>= bVScroll )
 317             {
 318                 m_xTableModel->setVerticalScrollbarVisibility( bVScroll ? ScrollbarShowAlways : ScrollbarShowSmart );
 319             }
 320             break;
 321         }
 322
 323         case BASEPROPERTY_GRID_SHOWROWHEADER:
 324         {
 325             bool rowHeader = true;
 326             if( aValue >>= rowHeader )
 327             {
 328                 m_xTableModel->setRowHeaders(rowHeader);
 329             }
 330             break;
 331         }
 332
 333         case BASEPROPERTY_GRID_ROW_BACKGROUND_COLORS:
 334             m_xTableModel->setRowBackgroundColors( aValue );
 335             pTable->Invalidate();
 336             break;
 337
 338         case BASEPROPERTY_GRID_LINE_COLOR:
 339             m_xTableModel->setLineColor( aValue );
 340             pTable->Invalidate();
 341             break;
 342
 343         case BASEPROPERTY_GRID_HEADER_BACKGROUND:
 344             m_xTableModel->setHeaderBackgroundColor( aValue );
 345             pTable->Invalidate();
 346             break;
 347
 348         case BASEPROPERTY_GRID_HEADER_TEXT_COLOR:
 349             m_xTableModel->setHeaderTextColor( aValue );
 350             pTable->Invalidate();
 351             break;
 352
 353         case BASEPROPERTY_ACTIVE_SEL_BACKGROUND_COLOR:
 354             m_xTableModel->setActiveSelectionBackColor( aValue );
 355             pTable->Invalidate();
 356             break;
 357
 358         case BASEPROPERTY_INACTIVE_SEL_BACKGROUND_COLOR:
 359             m_xTableModel->setInactiveSelectionBackColor( aValue );
 360             pTable->Invalidate();
 361             break;
 362
 363         case BASEPROPERTY_ACTIVE_SEL_TEXT_COLOR:
 364             m_xTableModel->setActiveSelectionTextColor( aValue );
 365             pTable->Invalidate();
 366             break;
 367
 368         case BASEPROPERTY_INACTIVE_SEL_TEXT_COLOR:
 369             m_xTableModel->setInactiveSelectionTextColor( aValue );
 370             pTable->Invalidate();
 371             break;
 372
 373
 374         case BASEPROPERTY_TEXTCOLOR:
 375             m_xTableModel->setTextColor( aValue );
 376             pTable->Invalidate();
 377             break;
 378
 379         case BASEPROPERTY_TEXTLINECOLOR:
 380             m_xTableModel->setTextLineColor( aValue );
 381             pTable->Invalidate();
 382             break;
 383
 384         case BASEPROPERTY_VERTICALALIGN:
 385         {
 386             VerticalAlignment eAlign( VerticalAlignment_TOP );
 387             if ( aValue >>= eAlign )
 388                 m_xTableModel->setVerticalAlign( eAlign );
 389             break;
 390         }
 391
 392         case BASEPROPERTY_GRID_SHOWCOLUMNHEADER:
 393         {
 394             bool colHeader = true;
 395             if( aValue >>= colHeader )
 396             {
 397                 m_xTableModel->setColumnHeaders(colHeader);
 398             }
 399             break;
 400         }
 401         case BASEPROPERTY_GRID_DATAMODEL:
 402         {
 403             Reference< XGridDataModel > const xDataModel( aValue, UNO_QUERY );
 404             if ( !xDataModel.is() )
 405                 throw GridInvalidDataException("Invalid data model.", *this );
 406
 407             m_xTableModel->setDataModel( xDataModel );
 408             impl_checkTableModelInit();
 409         }
 410         break;
 411
 412         case BASEPROPERTY_GRID_COLUMNMODEL:
 413         {
 414             // obtain new col model
 415             Reference< XGridColumnModel > const xColumnModel( aValue, UNO_QUERY );
 416             if ( !xColumnModel.is() )
 417                 throw GridInvalidModelException("Invalid column model.", *this );
 418
 419             // remove all old columns
 420             m_xTableModel->removeAllColumns();
 421
 422             // announce to the TableModel
 423             m_xTableModel->setColumnModel( xColumnModel );
 424             impl_checkTableModelInit();
 425
 426             // add new columns
 427             impl_updateColumnsFromModel_nothrow();
 428             break;
 429         }
 430         default:
 431             VCLXWindow::setProperty( PropertyName, aValue );
 432         break;
 433     }
 434 }
 435
 436
 437 void SVTXGridControl::impl_checkTableModelInit()
 438 {
 439     if ( !m_bTableModelInitCompleted && m_xTableModel->hasColumnModel() && m_xTableModel->hasDataModel() )
 440     {
 441         VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 442         if ( pTable )
 443         {
 444             pTable->SetModel( PTableModel( m_xTableModel ) );
 445
 446             m_bTableModelInitCompleted = true;
 447
 448             // ensure default columns exist, if they have not previously been added
 449             Reference< XGridDataModel > const xDataModel( m_xTableModel->getDataModel(), UNO_QUERY_THROW );
 450             Reference< XGridColumnModel > const xColumnModel( m_xTableModel->getColumnModel(), UNO_QUERY_THROW );
 451
 452             sal_Int32 const nDataColumnCount = xDataModel->getColumnCount();
 453             if ( ( nDataColumnCount > 0 ) && ( xColumnModel->getColumnCount() == 0 ) )
 454                 xColumnModel->setDefaultColumns( nDataColumnCount );
 455                 // this will trigger notifications, which in turn will let us update our m_xTableModel
 456         }
 457     }
 458 }
 459
 460 namespace
 461 {
 462     void lcl_convertColor( ::boost::optional< ::Color > const & i_color, Any & o_colorValue )
 463     {
 464         if ( !i_color )
 465             o_colorValue.clear();
 466         else
 467             o_colorValue <<= i_color->GetColor();
 468     }
 469 }
 470
 471 Any SVTXGridControl::getProperty( const OUString& PropertyName ) throw(RuntimeException, std::exception)
 472 {
 473     SolarMutexGuard aGuard;
 474
 475     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 476     ENSURE_OR_RETURN( pTable, "SVTXGridControl::getProperty: no control (anymore)!", Any() );
 477
 478     Any aPropertyValue;
 479
 480     const sal_uInt16 nPropId = GetPropertyId( PropertyName );
 481     switch(nPropId)
 482     {
 483     case BASEPROPERTY_GRID_SELECTIONMODE:
 484     {
 485         SelectionType eSelectionType;
 486
 487         SelectionMode eSelMode = pTable->getSelEngine()->GetSelectionMode();
 488         switch( eSelMode )
 489         {
 490             case SINGLE_SELECTION:  eSelectionType = SelectionType_SINGLE; break;
 491             case RANGE_SELECTION:   eSelectionType = SelectionType_RANGE; break;
 492             case MULTIPLE_SELECTION:eSelectionType = SelectionType_MULTI; break;
 493             default:                eSelectionType = SelectionType_NONE; break;
 494         }
 495         aPropertyValue <<= eSelectionType;
 496         break;
 497     }
 498
 499     case BASEPROPERTY_GRID_SHOWROWHEADER:
 500         aPropertyValue <<= m_xTableModel->hasRowHeaders();
 501         break;
 502
 503     case BASEPROPERTY_GRID_SHOWCOLUMNHEADER:
 504         aPropertyValue <<= m_xTableModel->hasColumnHeaders();
 505         break;
 506
 507     case BASEPROPERTY_GRID_DATAMODEL:
 508         aPropertyValue <<= m_xTableModel->getDataModel();
 509         break;
 510
 511     case BASEPROPERTY_GRID_COLUMNMODEL:
 512         aPropertyValue <<= m_xTableModel->getColumnModel();
 513         break;
 514
 515     case BASEPROPERTY_HSCROLL:
 516         {
 517             bool const bHasScrollbar = ( m_xTableModel->getHorizontalScrollbarVisibility() != ScrollbarShowNever );
 518             aPropertyValue <<= bHasScrollbar;
 519             break;
 520         }
 521
 522     case BASEPROPERTY_VSCROLL:
 523         {
 524             bool const bHasScrollbar = ( m_xTableModel->getVerticalScrollbarVisibility() != ScrollbarShowNever );
 525             aPropertyValue <<= bHasScrollbar;
 526             break;
 527         }
 528
 529     case BASEPROPERTY_USE_GRID_LINES:
 530     {
 531         GridTableRenderer* pGridRenderer = dynamic_cast< GridTableRenderer* >(
 532             m_xTableModel->getRenderer().get() );
 533         if ( !pGridRenderer )
 534         {
 535             SAL_WARN( "svtools.uno", "SVTXGridControl::getProperty(UseGridLines): invalid renderer!" );
 536             break;
 537         }
 538
 539         aPropertyValue <<= pGridRenderer->useGridLines();
 540     }
 541     break;
 542
 543     case BASEPROPERTY_GRID_ROW_BACKGROUND_COLORS:
 544     {
 545         ::boost::optional< ::std::vector< ::Color > > aColors( m_xTableModel->getRowBackgroundColors() );
 546         if ( !aColors )
 547             aPropertyValue.clear();
 548         else
 549         {
 550             Sequence< UnoColor > aAPIColors( aColors->size() );
 551             for ( size_t i=0; i<aColors->size(); ++i )
 552             {
 553                 aAPIColors[i] = aColors->at(i).GetColor();
 554             }
 555             aPropertyValue <<= aAPIColors;
 556         }
 557     }
 558     break;
 559
 560     case BASEPROPERTY_GRID_LINE_COLOR:
 561         lcl_convertColor( m_xTableModel->getLineColor(), aPropertyValue );
 562         break;
 563
 564     case BASEPROPERTY_GRID_HEADER_BACKGROUND:
 565         lcl_convertColor( m_xTableModel->getHeaderBackgroundColor(), aPropertyValue );
 566         break;
 567
 568     case BASEPROPERTY_GRID_HEADER_TEXT_COLOR:
 569         lcl_convertColor( m_xTableModel->getHeaderTextColor(), aPropertyValue );
 570         break;
 571
 572     case BASEPROPERTY_ACTIVE_SEL_BACKGROUND_COLOR:
 573         lcl_convertColor( m_xTableModel->getActiveSelectionBackColor(), aPropertyValue );
 574         break;
 575
 576     case BASEPROPERTY_INACTIVE_SEL_BACKGROUND_COLOR:
 577         lcl_convertColor( m_xTableModel->getInactiveSelectionBackColor(), aPropertyValue );
 578         break;
 579
 580     case BASEPROPERTY_ACTIVE_SEL_TEXT_COLOR:
 581         lcl_convertColor( m_xTableModel->getActiveSelectionTextColor(), aPropertyValue );
 582         break;
 583
 584     case BASEPROPERTY_INACTIVE_SEL_TEXT_COLOR:
 585         lcl_convertColor( m_xTableModel->getInactiveSelectionTextColor(), aPropertyValue );
 586         break;
 587
 588     case BASEPROPERTY_TEXTCOLOR:
 589         lcl_convertColor( m_xTableModel->getTextColor(), aPropertyValue );
 590         break;
 591
 592     case BASEPROPERTY_TEXTLINECOLOR:
 593         lcl_convertColor( m_xTableModel->getTextLineColor(), aPropertyValue );
 594         break;
 595
 596     default:
 597         aPropertyValue = VCLXWindow::getProperty( PropertyName );
 598         break;
 599     }
 600
 601     return aPropertyValue;
 602 }
 603
 604
 605 void SAL_CALL SVTXGridControl::rowsInserted( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
 606 {
 607     SolarMutexGuard aGuard;
 608     m_xTableModel->notifyRowsInserted( i_event );
 609 }
 610
 611
 612 void SAL_CALL
 613  SVTXGridControl::rowsRemoved( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
 614 {
 615     SolarMutexGuard aGuard;
 616     m_xTableModel->notifyRowsRemoved( i_event );
 617 }
 618
 619
 620 void SAL_CALL SVTXGridControl::dataChanged( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
 621 {
 622     SolarMutexGuard aGuard;
 623
 624     m_xTableModel->notifyDataChanged( i_event );
 625
 626     // if the data model is sortable, a dataChanged event is also fired in case the sort order changed.
 627     // So, just in case, invalidate the column header area, too.
 628     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 629     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::dataChanged: no control (anymore)!" );
 630     pTable->getTableControlInterface().invalidate( TableAreaColumnHeaders );
 631 }
 632
 633
 634 void SAL_CALL SVTXGridControl::rowHeadingChanged( const GridDataEvent& i_event ) throw (RuntimeException, std::exception)
 635 {
 636     SolarMutexGuard aGuard;
 637     OSL_UNUSED( i_event );
 638
 639     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 640     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::rowHeadingChanged: no control (anymore)!" );
 641
 642     // TODO: we could do better than this - invalidate the header area only
 643     pTable->getTableControlInterface().invalidate( TableAreaRowHeaders );
 644 }
 645
 646
 647 void SAL_CALL SVTXGridControl::elementInserted( const ContainerEvent& i_event ) throw (RuntimeException, std::exception)
 648 {
 649     SolarMutexGuard aGuard;
 650
 651     Reference< XGridColumn > const xGridColumn( i_event.Element, UNO_QUERY_THROW );
 652
 653     sal_Int32 nIndex( m_xTableModel->getColumnCount() );
 654     OSL_VERIFY( i_event.Accessor >>= nIndex );
 655     m_xTableModel->insertColumn( nIndex, xGridColumn );
 656 }
 657
 658
 659 void SAL_CALL SVTXGridControl::elementRemoved( const ContainerEvent& i_event ) throw (RuntimeException, std::exception)
 660 {
 661     SolarMutexGuard aGuard;
 662
 663     sal_Int32 nIndex( -1 );
 664     OSL_VERIFY( i_event.Accessor >>= nIndex );
 665     m_xTableModel->removeColumn( nIndex );
 666 }
 667
 668
 669 void SAL_CALL SVTXGridControl::elementReplaced( const ContainerEvent& i_event ) throw (RuntimeException, std::exception)
 670 {
 671     OSL_ENSURE( false, "SVTXGridControl::elementReplaced: not implemented!" );
 672         // at the moment, the XGridColumnModel API does not allow replacing columns
 673     OSL_UNUSED( i_event );
 674     // TODO: replace the respective column in our table model
 675 }
 676
 677
 678
 679 void SAL_CALL SVTXGridControl::disposing( const EventObject& Source ) throw(RuntimeException, std::exception)
 680 {
 681     VCLXWindow::disposing( Source );
 682 }
 683
 684
 685 void SAL_CALL SVTXGridControl::selectRow( ::sal_Int32 i_rowIndex ) throw (RuntimeException, IndexOutOfBoundsException, std::exception )
 686 {
 687     SolarMutexGuard aGuard;
 688
 689     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 690     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::selectRow: no control (anymore)!" );
 691
 692     impl_checkRowIndex_throw( *pTable, i_rowIndex );
 693
 694     pTable->SelectRow( i_rowIndex, true );
 695 }
 696
 697
 698 void SAL_CALL SVTXGridControl::selectAllRows() throw (RuntimeException, std::exception)
 699 {
 700     SolarMutexGuard aGuard;
 701
 702     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 703     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::selectAllRows: no control (anymore)!" );
 704
 705     pTable->SelectAllRows( true );
 706 }
 707
 708
 709 void SAL_CALL SVTXGridControl::deselectRow( ::sal_Int32 i_rowIndex ) throw (RuntimeException, IndexOutOfBoundsException, std::exception )
 710 {
 711     SolarMutexGuard aGuard;
 712
 713     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 714     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::deselectRow: no control (anymore)!" );
 715
 716     impl_checkRowIndex_throw( *pTable, i_rowIndex );
 717
 718     pTable->SelectRow( i_rowIndex, false );
 719 }
 720
 721
 722 void SAL_CALL SVTXGridControl::deselectAllRows() throw (RuntimeException, std::exception)
 723 {
 724     SolarMutexGuard aGuard;
 725
 726     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 727     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::deselectAllRows: no control (anymore)!" );
 728
 729     pTable->SelectAllRows( false );
 730 }
 731
 732
 733 Sequence< ::sal_Int32 > SAL_CALL SVTXGridControl::getSelectedRows() throw (RuntimeException, std::exception)
 734 {
 735     SolarMutexGuard aGuard;
 736
 737     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 738     ENSURE_OR_RETURN( pTable, "SVTXGridControl::getSelectedRows: no control (anymore)!", Sequence< sal_Int32 >() );
 739
 740     sal_Int32 selectionCount = pTable->GetSelectedRowCount();
 741     Sequence< sal_Int32 > selectedRows( selectionCount );
 742     for ( sal_Int32 i=0; i<selectionCount; ++i )
 743         selectedRows[i] = pTable->GetSelectedRowIndex(i);
 744     return selectedRows;
 745 }
 746
 747
 748 sal_Bool SAL_CALL SVTXGridControl::hasSelectedRows() throw (RuntimeException, std::exception)
 749 {
 750     SolarMutexGuard aGuard;
 751
 752     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 753     ENSURE_OR_RETURN( pTable, "SVTXGridControl::hasSelectedRows: no control (anymore)!", sal_True );
 754
 755     return pTable->GetSelectedRowCount() > 0;
 756 }
 757
 758
 759 sal_Bool SAL_CALL SVTXGridControl::isRowSelected( ::sal_Int32 index ) throw (RuntimeException, std::exception)
 760 {
 761     SolarMutexGuard aGuard;
 762
 763     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 764     ENSURE_OR_RETURN( pTable, "SVTXGridControl::isRowSelected: no control (anymore)!", sal_False );
 765
 766     return pTable->IsRowSelected( index );
 767 }
 768
 769
 770 void SVTXGridControl::dispose() throw(RuntimeException, std::exception)
 771 {
 772     EventObject aObj;
 773     aObj.Source = (::cppu::OWeakObject*)this;
 774     m_aSelectionListeners.disposeAndClear( aObj );
 775     VCLXWindow::dispose();
 776 }
 777
 778
 779 void SVTXGridControl::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 780 {
 781     SolarMutexGuard aGuard;
 782
 783     Reference< XWindow > xKeepAlive( this );
 784
 785     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 786     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::ProcessWindowEvent: no control (anymore)!" );
 787
 788     bool handled = false;
 789     switch ( rVclWindowEvent.GetId() )
 790     {
 791         case VCLEVENT_TABLEROW_SELECT:
 792         {
 793             if ( m_aSelectionListeners.getLength() )
 794                 ImplCallItemListeners();
 795             handled = true;
 796         }
 797         break;
 798
 799         case VCLEVENT_CONTROL_GETFOCUS:
 800         {
 801             // TODO: this doesn't belong here. It belongs into the TableControl/_Impl, so A11Y also
 802             // works when the control is used outside the UNO context
 803              if ( pTable->GetRowCount()>0 )
 804              {
 805                 pTable->commitCellEventIfAccessibleAlive(
 806                     AccessibleEventId::STATE_CHANGED,
 807                     makeAny( AccessibleStateType::FOCUSED ),
 808                     Any()
 809                 );
 810                 pTable->commitTableEventIfAccessibleAlive(
 811                     AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
 812                     Any(),
 813                     Any()
 814                 );
 815             }
 816             else
 817             {
 818                 pTable->commitTableEventIfAccessibleAlive(
 819                     AccessibleEventId::STATE_CHANGED,
 820                     makeAny( AccessibleStateType::FOCUSED ),
 821                     Any()
 822                 );
 823              }
 824         }
 825         break;
 826
 827         case VCLEVENT_CONTROL_LOSEFOCUS:
 828         {
 829             // TODO: this doesn't belong here. It belongs into the TableControl/_Impl, so A11Y also
 830             // works when the control is used outside the UNO context
 831             if ( pTable->GetRowCount()>0 )
 832             {
 833                 pTable->commitCellEventIfAccessibleAlive(
 834                     AccessibleEventId::STATE_CHANGED,
 835                     Any(),
 836                     makeAny( AccessibleStateType::FOCUSED )
 837                 );
 838             }
 839             else
 840             {
 841                 pTable->commitTableEventIfAccessibleAlive(
 842                     AccessibleEventId::STATE_CHANGED,
 843                     Any(),
 844                     makeAny( AccessibleStateType::FOCUSED )
 845                 );
 846             }
 847         }
 848         break;
 849     }
 850
 851     if ( !handled )
 852         VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
 853 }
 854
 855
 856 void SVTXGridControl::setEnable( sal_Bool bEnable ) throw(::com::sun::star::uno::RuntimeException, std::exception)
 857 {
 858     SolarMutexGuard aGuard;
 859
 860     m_xTableModel->setEnabled( bEnable );
 861     vcl::Window * pWindow = GetWindow();
 862     if ( pWindow )
 863     {
 864         pWindow->Enable( bEnable, true );
 865         pWindow->EnableInput( bEnable );
 866         pWindow->Invalidate();
 867     }
 868 }
 869
 870
 871 void SVTXGridControl::ImplCallItemListeners()
 872 {
 873     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 874     ENSURE_OR_RETURN_VOID( pTable, "SVTXGridControl::ImplCallItemListeners: no control (anymore)!" );
 875
 876     if ( m_aSelectionListeners.getLength() )
 877     {
 878         GridSelectionEvent aEvent;
 879         aEvent.Source = (::cppu::OWeakObject*)this;
 880
 881         sal_Int32 const nSelectedRowCount( pTable->GetSelectedRowCount() );
 882         aEvent.SelectedRowIndexes.realloc( nSelectedRowCount );
 883         for ( sal_Int32 i=0; i<nSelectedRowCount; ++i )
 884             aEvent.SelectedRowIndexes[i] = pTable->GetSelectedRowIndex( i );
 885         m_aSelectionListeners.selectionChanged( aEvent );
 886     }
 887 }
 888
 889
 890 void SVTXGridControl::impl_updateColumnsFromModel_nothrow()
 891 {
 892     Reference< XGridColumnModel > const xColumnModel( m_xTableModel->getColumnModel() );
 893     ENSURE_OR_RETURN_VOID( xColumnModel.is(), "no model!" );
 894     VclPtr< TableControl > pTable = GetAsDynamic< TableControl >();
 895     ENSURE_OR_RETURN_VOID( pTable, "no table!" );
 896
 897     try
 898     {
 899         const Sequence< Reference< XGridColumn > > columns = xColumnModel->getColumns();
 900         for (   const Reference< XGridColumn >* colRef = columns.getConstArray();
 901                 colRef != columns.getConstArray() + columns.getLength();
 902                 ++colRef
 903             )
 904         {
 905             if ( !colRef->is() )
 906             {
 907                 SAL_WARN( "svtools.uno", "illegal column!" );
 908                 continue;
 909             }
 910
 911             m_xTableModel->appendColumn( *colRef );
 912         }
 913     }
 914     catch( const Exception& )
 915     {
 916         DBG_UNHANDLED_EXCEPTION();
 917     }
 918 }
 919
 920 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */