svtools/source/table/tablecontrol.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 "table/tablecontrol.hxx"
  21
  22 #include "tablegeometry.hxx"
  23 #include "tablecontrol_impl.hxx"
  24 #include "tabledatawindow.hxx"
  25
  26 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  27 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  28 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  29
  30 #include <tools/diagnose_ex.h>
  31 #include <vcl/settings.hxx>
  32
  33 using namespace ::com::sun::star::uno;
  34 using ::com::sun::star::accessibility::XAccessible;
  35 using namespace ::com::sun::star::accessibility;
  36 using namespace ::com::sun::star::lang;
  37 using namespace utl;
  38
  39 namespace svt { namespace table
  40 {
  41
  42
  43     namespace AccessibleEventId = ::com::sun::star::accessibility::AccessibleEventId;
  44
  45
  46     //= TableControl
  47
  48
  49     TableControl::TableControl( vcl::Window* _pParent, WinBits _nStyle )
  50         :Control( _pParent, _nStyle )
  51         ,m_pImpl( new TableControl_Impl( *this ) )
  52     {
  53         TableDataWindow& rDataWindow = m_pImpl->getDataWindow();
  54         rDataWindow.SetSelectHdl( LINK( this, TableControl, ImplSelectHdl ) );
  55
  56         // by default, use the background as determined by the style settings
  57         const Color aWindowColor( GetSettings().GetStyleSettings().GetFieldColor() );
  58         SetBackground( Wallpaper( aWindowColor ) );
  59         SetFillColor( aWindowColor );
  60
  61         SetCompoundControl( true );
  62     }
  63
  64
  65     TableControl::~TableControl()
  66     {
  67         disposeOnce();
  68     }
  69
  70     void TableControl::dispose()
  71     {
  72         CallEventListeners( VCLEVENT_OBJECT_DYING );
  73
  74         m_pImpl->setModel( PTableModel() );
  75         m_pImpl->disposeAccessible();
  76         m_pImpl.reset();
  77         Control::dispose();
  78     }
  79
  80
  81     void TableControl::GetFocus()
  82     {
  83         if ( !m_pImpl || !m_pImpl->getInputHandler()->GetFocus( *m_pImpl ) )
  84             Control::GetFocus();
  85     }
  86
  87
  88     void TableControl::LoseFocus()
  89     {
  90         if ( !m_pImpl || !m_pImpl->getInputHandler()->LoseFocus( *m_pImpl ) )
  91             Control::LoseFocus();
  92     }
  93
  94
  95     void TableControl::KeyInput( const KeyEvent& rKEvt )
  96     {
  97         if ( !m_pImpl->getInputHandler()->KeyInput( *m_pImpl, rKEvt ) )
  98             Control::KeyInput( rKEvt );
  99         else
 100         {
 101             if ( m_pImpl->isAccessibleAlive() )
 102             {
 103                 m_pImpl->commitCellEvent( AccessibleEventId::STATE_CHANGED,
 104                                           makeAny( AccessibleStateType::FOCUSED ),
 105                                           Any()
 106                                         );
 107                     // Huh? What the heck? Why do we unconditionally notify a STATE_CHANGE/FOCUSED after each and every
 108                     // (handled) key stroke?
 109
 110                 m_pImpl->commitTableEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
 111                                            Any(),
 112                                            Any()
 113                                          );
 114                     // ditto: Why do we notify this unconditionally? We should find the right place to notify the
 115                     // ACTIVE_DESCENDANT_CHANGED event.
 116                     // Also, we should check if STATE_CHANGED/FOCUSED is really necessary: finally, the children are
 117                     // transient, aren't they?
 118             }
 119         }
 120     }
 121
 122
 123
 124     void TableControl::StateChanged( StateChangedType i_nStateChange )
 125     {
 126         Control::StateChanged( i_nStateChange );
 127
 128         // forward certain settings to the data window
 129         switch ( i_nStateChange )
 130         {
 131         case StateChangedType::ControlFocus:
 132             m_pImpl->invalidateSelectedRows();
 133             break;
 134
 135         case StateChangedType::ControlBackground:
 136             if ( IsControlBackground() )
 137                 getDataWindow().SetControlBackground( GetControlBackground() );
 138             else
 139                 getDataWindow().SetControlBackground();
 140             break;
 141
 142         case StateChangedType::ControlForeground:
 143             if ( IsControlForeground() )
 144                 getDataWindow().SetControlForeground( GetControlForeground() );
 145             else
 146                 getDataWindow().SetControlForeground();
 147             break;
 148
 149         case StateChangedType::ControlFont:
 150             if ( IsControlFont() )
 151                 getDataWindow().SetControlFont( GetControlFont() );
 152             else
 153                 getDataWindow().SetControlFont();
 154             break;
 155         default:;
 156         }
 157     }
 158
 159
 160     void TableControl::Resize()
 161     {
 162         Control::Resize();
 163         m_pImpl->onResize();
 164     }
 165
 166
 167     void TableControl::SetModel( PTableModel _pModel )
 168     {
 169         m_pImpl->setModel( _pModel );
 170     }
 171
 172
 173     PTableModel TableControl::GetModel() const
 174     {
 175         return m_pImpl->getModel();
 176     }
 177
 178
 179     sal_Int32 TableControl::GetCurrentRow() const
 180     {
 181         return m_pImpl->getCurrentRow();
 182     }
 183
 184
 185     sal_Int32 TableControl::GetCurrentColumn() const
 186     {
 187         return m_pImpl->getCurrentColumn();
 188     }
 189
 190
 191     bool TableControl::GoTo( ColPos _nColumn, RowPos _nRow )
 192     {
 193         return m_pImpl->goTo( _nColumn, _nRow );
 194     }
 195
 196
 197     bool TableControl::GoToCell(sal_Int32 _nColPos, sal_Int32 _nRowPos)
 198     {
 199         return m_pImpl->goTo( _nColPos, _nRowPos );
 200     }
 201
 202
 203     sal_Int32 TableControl::GetSelectedRowCount() const
 204     {
 205         return sal_Int32( m_pImpl->getSelectedRowCount() );
 206     }
 207
 208
 209     sal_Int32 TableControl::GetSelectedRowIndex( sal_Int32 const i_selectionIndex ) const
 210     {
 211         return sal_Int32( m_pImpl->getSelectedRowIndex( i_selectionIndex ) );
 212     }
 213
 214
 215     bool TableControl::IsRowSelected( sal_Int32 const i_rowIndex ) const
 216     {
 217         return m_pImpl->isRowSelected( i_rowIndex );
 218     }
 219
 220
 221     void TableControl::SelectRow( RowPos const i_rowIndex, bool const i_select )
 222     {
 223         ENSURE_OR_RETURN_VOID( ( i_rowIndex >= 0 ) && ( i_rowIndex < m_pImpl->getModel()->getRowCount() ),
 224             "TableControl::SelectRow: invalid row index!" );
 225
 226         if ( i_select )
 227         {
 228             if ( !m_pImpl->markRowAsSelected( i_rowIndex ) )
 229                 // nothing to do
 230                 return;
 231         }
 232         else
 233         {
 234             m_pImpl->markRowAsDeselected( i_rowIndex );
 235         }
 236
 237         m_pImpl->invalidateRowRange( i_rowIndex, i_rowIndex );
 238         Select();
 239     }
 240
 241
 242     void TableControl::SelectAllRows( bool const i_select )
 243     {
 244         if ( i_select )
 245         {
 246             if ( !m_pImpl->markAllRowsAsSelected() )
 247                 // nothing to do
 248                 return;
 249         }
 250         else
 251         {
 252             if ( !m_pImpl->markAllRowsAsDeselected() )
 253                 // nothing to do
 254                 return;
 255         }
 256
 257
 258         Invalidate();
 259             // TODO: can't we do better than this, and invalidate only the rows which changed?
 260         Select();
 261     }
 262
 263
 264     ITableControl& TableControl::getTableControlInterface()
 265     {
 266         return *m_pImpl;
 267     }
 268
 269
 270     SelectionEngine* TableControl::getSelEngine()
 271     {
 272         return m_pImpl->getSelEngine();
 273     }
 274
 275
 276     vcl::Window& TableControl::getDataWindow()
 277     {
 278         return m_pImpl->getDataWindow();
 279     }
 280
 281
 282     Reference< XAccessible > TableControl::CreateAccessible()
 283     {
 284         vcl::Window* pParent = GetAccessibleParentWindow();
 285         ENSURE_OR_RETURN( pParent, "TableControl::CreateAccessible - parent not found", NULL );
 286
 287         return m_pImpl->getAccessible( *pParent );
 288     }
 289
 290
 291     Reference<XAccessible> TableControl::CreateAccessibleControl( sal_Int32 _nIndex )
 292     {
 293         (void)_nIndex;
 294         DBG_ASSERT( false, "TableControl::CreateAccessibleControl: to be overwritten!" );
 295         return NULL;
 296     }
 297
 298
 299     OUString TableControl::GetAccessibleObjectName( AccessibleTableControlObjType eObjType, sal_Int32 _nRow, sal_Int32 _nCol) const
 300     {
 301         OUString aRetText;
 302         //Window* pWin;
 303         switch( eObjType )
 304         {
 305             case TCTYPE_GRIDCONTROL:
 306                 aRetText = "Grid control";
 307                 break;
 308             case TCTYPE_TABLE:
 309                 aRetText = "Grid conrol";
 310                 break;
 311             case TCTYPE_ROWHEADERBAR:
 312                 aRetText = "RowHeaderBar";
 313                 break;
 314             case TCTYPE_COLUMNHEADERBAR:
 315                 aRetText = "ColumnHeaderBar";
 316                 break;
 317             case TCTYPE_TABLECELL:
 318                 //the name of the cell constists of column name and row name if defined
 319                 //if the name is equal to cell content, it'll be read twice
 320                 if(GetModel()->hasColumnHeaders())
 321                 {
 322                     aRetText = GetColumnName(_nCol) + " , ";
 323                 }
 324                 if(GetModel()->hasRowHeaders())
 325                 {
 326                     aRetText += GetRowName(_nRow) + " , ";
 327                 }
 328                 //aRetText = GetAccessibleCellText(_nRow, _nCol);
 329                 break;
 330             case TCTYPE_ROWHEADERCELL:
 331                 aRetText = GetRowName(_nRow);
 332                 break;
 333             case TCTYPE_COLUMNHEADERCELL:
 334                 aRetText = GetColumnName(_nCol);
 335                 break;
 336             default:
 337                 OSL_FAIL("GridControl::GetAccessibleName: invalid enum!");
 338         }
 339         return aRetText;
 340     }
 341
 342
 343     OUString TableControl::GetAccessibleObjectDescription( AccessibleTableControlObjType eObjType, sal_Int32 ) const
 344     {
 345         OUString aRetText;
 346         switch( eObjType )
 347         {
 348             case TCTYPE_GRIDCONTROL:
 349                 aRetText = "Grid control description";
 350                 break;
 351             case TCTYPE_TABLE:
 352                     aRetText = "TABLE description";
 353                 break;
 354             case TCTYPE_ROWHEADERBAR:
 355                     aRetText = "ROWHEADERBAR description";
 356                 break;
 357             case TCTYPE_COLUMNHEADERBAR:
 358                     aRetText = "COLUMNHEADERBAR description";
 359                 break;
 360             case TCTYPE_TABLECELL:
 361                 // the description of the cell consists of column name and row name if defined
 362                 // if the name is equal to cell content, it'll be read twice
 363                 if ( GetModel()->hasColumnHeaders() )
 364                 {
 365                     aRetText = GetColumnName( GetCurrentColumn() ) + " , ";
 366                 }
 367                 if ( GetModel()->hasRowHeaders() )
 368                 {
 369                     aRetText += GetRowName( GetCurrentRow() );
 370                 }
 371                 break;
 372             case TCTYPE_ROWHEADERCELL:
 373                     aRetText = "ROWHEADERCELL description";
 374                 break;
 375             case TCTYPE_COLUMNHEADERCELL:
 376                     aRetText = "COLUMNHEADERCELL description";
 377                 break;
 378         }
 379         return aRetText;
 380     }
 381
 382
 383     OUString TableControl::GetRowDescription( sal_Int32 _nRow) const
 384     {
 385         (void)_nRow;
 386         return OUString( "row description" );
 387     }
 388
 389
 390     OUString TableControl::GetRowName( sal_Int32 _nIndex) const
 391     {
 392         OUString sRowName;
 393         GetModel()->getRowHeading( _nIndex ) >>= sRowName;
 394         return sRowName;
 395     }
 396
 397
 398     OUString TableControl::GetColumnDescription( sal_uInt16 _nColumn) const
 399     {
 400         (void)_nColumn;
 401         return OUString( "col description" );
 402     }
 403
 404
 405     OUString TableControl::GetColumnName( sal_Int32 _nIndex) const
 406     {
 407         return GetModel()->getColumnModel(_nIndex)->getName();
 408     }
 409
 410
 411     ::com::sun::star::uno::Any TableControl::GetCellContent( sal_Int32 _nRowPos, sal_Int32 _nColPos ) const
 412     {
 413         Any aCellContent;
 414         GetModel()->getCellContent( _nColPos, _nRowPos, aCellContent );
 415         return aCellContent;
 416     }
 417
 418
 419     OUString TableControl::GetAccessibleCellText( sal_Int32 _nRowPos, sal_Int32 _nColPos) const
 420     {
 421         return m_pImpl->getCellContentAsString( _nRowPos, _nColPos );
 422     }
 423
 424
 425     void TableControl::FillAccessibleStateSet(
 426             ::utl::AccessibleStateSetHelper& rStateSet,
 427             AccessibleTableControlObjType eObjType ) const
 428     {
 429         switch( eObjType )
 430         {
 431             case TCTYPE_GRIDCONTROL:
 432             case TCTYPE_TABLE:
 433
 434                 rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 435
 436                 if ( m_pImpl->getSelEngine()->GetSelectionMode() == MULTIPLE_SELECTION )
 437                     rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE);
 438
 439                 if ( HasChildPathFocus() )
 440                     rStateSet.AddState( AccessibleStateType::FOCUSED );
 441
 442                 if ( IsActive() )
 443                     rStateSet.AddState( AccessibleStateType::ACTIVE );
 444
 445                 if ( m_pImpl->getDataWindow().IsEnabled() )
 446                 {
 447                     rStateSet.AddState( AccessibleStateType::ENABLED );
 448                     rStateSet.AddState( AccessibleStateType::SENSITIVE );
 449                 }
 450
 451                 if ( IsReallyVisible() )
 452                     rStateSet.AddState( AccessibleStateType::VISIBLE );
 453
 454                 if ( eObjType == TCTYPE_TABLE )
 455                     rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
 456                 break;
 457
 458             case TCTYPE_ROWHEADERBAR:
 459                 rStateSet.AddState( AccessibleStateType::VISIBLE );
 460                 rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
 461                 break;
 462
 463             case TCTYPE_COLUMNHEADERBAR:
 464                 rStateSet.AddState( AccessibleStateType::VISIBLE );
 465                 rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
 466                 break;
 467
 468             case TCTYPE_TABLECELL:
 469                 {
 470                     rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 471                     if ( HasChildPathFocus() )
 472                         rStateSet.AddState( AccessibleStateType::FOCUSED );
 473                     rStateSet.AddState( AccessibleStateType::ACTIVE );
 474                     rStateSet.AddState( AccessibleStateType::TRANSIENT );
 475                     rStateSet.AddState( AccessibleStateType::SELECTABLE);
 476                     rStateSet.AddState( AccessibleStateType::VISIBLE );
 477                     rStateSet.AddState( AccessibleStateType::SHOWING );
 478                     if ( IsRowSelected( GetCurrentRow() ) )
 479                         // Hmm? Wouldn't we expect the affected row to be a parameter to this function?
 480                         rStateSet.AddState( AccessibleStateType::SELECTED );
 481                 }
 482                 break;
 483
 484             case TCTYPE_ROWHEADERCELL:
 485                 rStateSet.AddState( AccessibleStateType::VISIBLE );
 486                 rStateSet.AddState( AccessibleStateType::TRANSIENT );
 487                 break;
 488
 489             case TCTYPE_COLUMNHEADERCELL:
 490                 rStateSet.AddState( AccessibleStateType::VISIBLE );
 491                 break;
 492         }
 493     }
 494
 495
 496     void TableControl::commitCellEventIfAccessibleAlive( sal_Int16 const i_eventID, const Any& i_newValue, const Any& i_oldValue )
 497     {
 498         if ( m_pImpl->isAccessibleAlive() )
 499             m_pImpl->commitCellEvent( i_eventID, i_newValue, i_oldValue );
 500     }
 501
 502
 503     void TableControl::commitTableEventIfAccessibleAlive( sal_Int16 const i_eventID, const Any& i_newValue, const Any& i_oldValue )
 504     {
 505         if ( m_pImpl->isAccessibleAlive() )
 506             m_pImpl->commitTableEvent( i_eventID, i_newValue, i_oldValue );
 507     }
 508
 509
 510     Rectangle TableControl::GetWindowExtentsRelative( vcl::Window *pRelativeWindow ) const
 511     {
 512         return Control::GetWindowExtentsRelative( pRelativeWindow );
 513     }
 514
 515
 516     void TableControl::GrabFocus()
 517     {
 518         Control::GrabFocus();
 519     }
 520
 521
 522     Reference< XAccessible > TableControl::GetAccessible( bool bCreate )
 523     {
 524         return Control::GetAccessible( bCreate );
 525     }
 526
 527
 528     vcl::Window* TableControl::GetAccessibleParentWindow() const
 529     {
 530         return Control::GetAccessibleParentWindow();
 531     }
 532
 533
 534     vcl::Window* TableControl::GetWindowInstance()
 535     {
 536         return this;
 537     }
 538
 539
 540     bool TableControl::HasRowHeader()
 541     {
 542         return GetModel()->hasRowHeaders();
 543     }
 544
 545
 546     bool TableControl::HasColHeader()
 547     {
 548         return GetModel()->hasColumnHeaders();
 549     }
 550
 551
 552     sal_Int32 TableControl::GetAccessibleControlCount() const
 553     {
 554         // TC_TABLE is always defined, no matter whether empty or not
 555         sal_Int32 count = 1;
 556         if ( GetModel()->hasRowHeaders() )
 557             ++count;
 558         if ( GetModel()->hasColumnHeaders() )
 559             ++count;
 560         return count;
 561     }
 562
 563
 564     bool TableControl::ConvertPointToControlIndex( sal_Int32& _rnIndex, const Point& _rPoint )
 565     {
 566         sal_Int32 nRow = m_pImpl->getRowAtPoint( _rPoint );
 567         sal_Int32 nCol = m_pImpl->getColAtPoint( _rPoint );
 568         _rnIndex = nRow * GetColumnCount() + nCol;
 569         return nRow >= 0;
 570     }
 571
 572
 573     long TableControl::GetRowCount() const
 574     {
 575         return GetModel()->getRowCount();
 576     }
 577
 578
 579     long TableControl::GetColumnCount() const
 580     {
 581         return GetModel()->getColumnCount();
 582     }
 583
 584
 585     bool TableControl::HasRowHeader() const
 586     {
 587         return GetModel()->hasRowHeaders();
 588     }
 589
 590
 591     bool TableControl::ConvertPointToCellAddress( sal_Int32& _rnRow, sal_Int32& _rnColPos, const Point& _rPoint )
 592     {
 593         _rnRow = m_pImpl->getRowAtPoint( _rPoint );
 594         _rnColPos = m_pImpl->getColAtPoint( _rPoint );
 595         return _rnRow >= 0;
 596     }
 597
 598
 599     void TableControl::FillAccessibleStateSetForCell( ::utl::AccessibleStateSetHelper& _rStateSet, sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const
 600     {
 601         if ( IsRowSelected( _nRow ) )
 602             _rStateSet.AddState( AccessibleStateType::SELECTED );
 603         if ( HasChildPathFocus() )
 604             _rStateSet.AddState( AccessibleStateType::FOCUSED );
 605         else // only transient when column is not focused
 606             _rStateSet.AddState( AccessibleStateType::TRANSIENT );
 607
 608         _rStateSet.AddState( AccessibleStateType::VISIBLE );
 609         _rStateSet.AddState( AccessibleStateType::SHOWING );
 610         _rStateSet.AddState( AccessibleStateType::ENABLED );
 611         _rStateSet.AddState( AccessibleStateType::SENSITIVE );
 612         _rStateSet.AddState( AccessibleStateType::ACTIVE );
 613
 614         (void)_nColumnPos;
 615     }
 616
 617
 618     Rectangle TableControl::GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex)
 619     {
 620         (void)_nRow;
 621         (void)_nColumnPos;
 622         return GetCharacterBounds(nIndex);
 623     }
 624
 625
 626     sal_Int32 TableControl::GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint)
 627     {
 628         (void)_nRow;
 629         (void)_nColumnPos;
 630         return GetIndexForPoint(_rPoint);
 631     }
 632
 633
 634     Rectangle TableControl::calcHeaderRect(bool _bIsColumnBar, bool _bOnScreen)
 635     {
 636         (void)_bOnScreen;
 637         return m_pImpl->calcHeaderRect( !_bIsColumnBar );
 638     }
 639
 640
 641     Rectangle TableControl::calcHeaderCellRect( bool _bIsColumnBar, sal_Int32 nPos )
 642     {
 643         return m_pImpl->calcHeaderCellRect( _bIsColumnBar, nPos );
 644     }
 645
 646
 647     Rectangle TableControl::calcTableRect(bool _bOnScreen)
 648     {
 649         (void)_bOnScreen;
 650         return m_pImpl->calcTableRect();
 651     }
 652
 653
 654     Rectangle TableControl::calcCellRect( sal_Int32 _nRowPos, sal_Int32 _nColPos )
 655     {
 656         return m_pImpl->calcCellRect( _nRowPos, _nColPos );
 657     }
 658
 659
 660     IMPL_LINK_NOARG(TableControl, ImplSelectHdl)
 661     {
 662         Select();
 663         return 1;
 664     }
 665
 666
 667     void TableControl::Select()
 668     {
 669         ImplCallEventListenersAndHandler( VCLEVENT_TABLEROW_SELECT, m_pImpl->getSelectHandler(), this );
 670
 671         if ( m_pImpl->isAccessibleAlive() )
 672         {
 673             m_pImpl->commitAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 674
 675             m_pImpl->commitTableEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), Any() );
 676                 // TODO: why do we notify this when the *selection* changed? Shouldn't we find a better place for this,
 677                 // actually, when the active descendant, i.e. the current cell, *really* changed?
 678         }
 679     }
 680
 681 }} // namespace svt::table
 682
 683
 684 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */