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