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 :
21 : #include <com/sun/star/table/XMergeableCell.hpp>
22 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
23 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
24 :
25 : #include <comphelper/accessiblewrapper.hxx>
26 : #include <osl/mutex.hxx>
27 : #include <vcl/svapp.hxx>
28 :
29 : #include <svx/AccessibleTableShape.hxx>
30 : #include <svx/sdr/table/tablecontroller.hxx>
31 : #include "accessiblecell.hxx"
32 :
33 : #include <algorithm>
34 :
35 : #include <cppuhelper/implbase1.hxx>
36 : #include <svx/svdotable.hxx>
37 : #include <com/sun/star/view/XSelectionSupplier.hpp>
38 :
39 :
40 : using namespace ::accessibility;
41 : using namespace ::sdr::table;
42 : using namespace ::com::sun::star::accessibility;
43 : using namespace ::com::sun::star::uno;
44 : using namespace ::com::sun::star::beans;
45 : using namespace ::com::sun::star::util;
46 : using namespace ::com::sun::star::lang;
47 : using namespace ::com::sun::star::drawing;
48 : using namespace ::com::sun::star::table;
49 : using namespace ::com::sun::star::container;
50 :
51 : namespace accessibility
52 : {
53 :
54 : struct hash
55 : {
56 0 : std::size_t operator()( const Reference< XCell >& xCell ) const
57 : {
58 0 : return std::size_t( xCell.get() );
59 : }
60 : };
61 :
62 : typedef boost::unordered_map< Reference< XCell >, rtl::Reference< AccessibleCell >, hash > AccessibleCellMap;
63 :
64 :
65 : // AccessibleTableShapeImpl
66 :
67 :
68 0 : class AccessibleTableShapeImpl : public cppu::WeakImplHelper1< XModifyListener >
69 : {
70 : public:
71 : AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo );
72 :
73 : void init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable );
74 : void dispose();
75 :
76 : Reference< XAccessible > getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException);
77 : void getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException );
78 :
79 : // XModifyListener
80 : virtual void SAL_CALL modified( const EventObject& aEvent ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
81 :
82 : // XEventListener
83 : virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
84 :
85 : AccessibleShapeTreeInfo& mrShapeTreeInfo;
86 : Reference< XTable > mxTable;
87 : AccessibleCellMap maChildMap;
88 : Reference< XAccessible> mxAccessible;
89 : sal_Int32 mRowCount, mColCount;
90 : //get the cached AccessibleCell from XCell
91 : Reference< AccessibleCell > getAccessibleCell (Reference< XCell > xCell);
92 : };
93 :
94 :
95 :
96 0 : AccessibleTableShapeImpl::AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo )
97 : : mrShapeTreeInfo( rShapeTreeInfo )
98 : , mRowCount(0)
99 0 : , mColCount(0)
100 : {
101 0 : }
102 :
103 :
104 :
105 0 : void AccessibleTableShapeImpl::init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable )
106 : {
107 0 : mxAccessible = xAccessible;
108 0 : mxTable = xTable;
109 :
110 0 : if( mxTable.is() )
111 : {
112 0 : Reference< XModifyListener > xListener( this );
113 0 : mxTable->addModifyListener( xListener );
114 : //register the listener with table model
115 0 : Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(xTable, UNO_QUERY);
116 0 : Reference< ::com::sun::star::view::XSelectionChangeListener > xSelListener( xAccessible, UNO_QUERY );
117 0 : if (xSelSupplier.is())
118 0 : xSelSupplier->addSelectionChangeListener(xSelListener);
119 0 : mRowCount = mxTable->getRowCount();
120 0 : mColCount = mxTable->getColumnCount();
121 : }
122 0 : }
123 :
124 :
125 :
126 0 : void AccessibleTableShapeImpl::dispose()
127 : {
128 0 : if( mxTable.is() )
129 : {
130 : //remove all the cell's acc object in table's dispose.
131 0 : for( AccessibleCellMap::iterator iter( maChildMap.begin() ); iter != maChildMap.end(); ++iter )
132 : {
133 0 : (*iter).second->dispose();
134 : }
135 0 : maChildMap.clear();
136 0 : Reference< XModifyListener > xListener( this );
137 0 : mxTable->removeModifyListener( xListener );
138 0 : mxTable.clear();
139 : }
140 0 : mxAccessible.clear();
141 0 : }
142 :
143 :
144 : //get the cached AccessibleCell from XCell
145 0 : Reference< AccessibleCell > AccessibleTableShapeImpl::getAccessibleCell (Reference< XCell > xCell)
146 : {
147 0 : AccessibleCellMap::iterator iter( maChildMap.find( xCell ) );
148 :
149 0 : if( iter != maChildMap.end() )
150 : {
151 0 : Reference< AccessibleCell > xChild( (*iter).second.get() );
152 0 : return xChild;
153 : }
154 0 : return Reference< AccessibleCell >();
155 : }
156 :
157 :
158 0 : Reference< XAccessible > AccessibleTableShapeImpl::getAccessibleChild( sal_Int32 nChildIndex ) throw(IndexOutOfBoundsException)
159 : {
160 0 : sal_Int32 nColumn = 0, nRow = 0;
161 0 : getColumnAndRow( nChildIndex, nColumn, nRow );
162 :
163 0 : Reference< XCell > xCell( mxTable->getCellByPosition( nColumn, nRow ) );
164 0 : AccessibleCellMap::iterator iter( maChildMap.find( xCell ) );
165 :
166 0 : if( iter != maChildMap.end() )
167 : {
168 0 : Reference< XAccessible > xChild( (*iter).second.get() );
169 0 : return xChild;
170 : }
171 : else
172 : {
173 0 : CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) );
174 :
175 0 : rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) );
176 :
177 0 : xAccessibleCell->Init();
178 0 : maChildMap[xCell] = xAccessibleCell;
179 :
180 0 : Reference< XAccessible > xChild( xAccessibleCell.get() );
181 0 : return xChild;
182 0 : }
183 : }
184 :
185 :
186 :
187 0 : void AccessibleTableShapeImpl::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException )
188 : {
189 0 : rnRow = 0;
190 0 : rnColumn = nChildIndex;
191 :
192 0 : if( mxTable.is() )
193 : {
194 0 : const sal_Int32 nColumnCount = mxTable->getColumnCount();
195 0 : while( rnColumn >= nColumnCount )
196 : {
197 0 : rnRow++;
198 0 : rnColumn -= nColumnCount;
199 : }
200 :
201 0 : if( rnRow < mxTable->getRowCount() )
202 0 : return;
203 : }
204 :
205 0 : throw IndexOutOfBoundsException();
206 : }
207 :
208 : // XModifyListener
209 0 : void SAL_CALL AccessibleTableShapeImpl::modified( const EventObject& /*aEvent*/ ) throw (RuntimeException, std::exception)
210 : {
211 0 : if( mxTable.is() ) try
212 : {
213 : // structural changes may have happened to the table, validate all accessible cell instances
214 0 : AccessibleCellMap aTempChildMap;
215 0 : aTempChildMap.swap( maChildMap );
216 :
217 : // first move all still existing cells to maChildMap again and update their index
218 :
219 0 : const sal_Int32 nRowCount = mxTable->getRowCount();
220 0 : const sal_Int32 nColCount = mxTable->getColumnCount();
221 :
222 0 : sal_Bool bRowOrColumnChanged = sal_False;
223 0 : if (mRowCount != nRowCount || mColCount != nColCount )
224 : {
225 0 : bRowOrColumnChanged = sal_True;
226 0 : mRowCount = nRowCount;
227 0 : mColCount = nColCount;
228 : }
229 0 : sal_Int32 nChildIndex = 0;
230 :
231 0 : for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
232 : {
233 0 : for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
234 : {
235 0 : Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) );
236 0 : AccessibleCellMap::iterator iter( aTempChildMap.find( xCell ) );
237 :
238 0 : if( iter != aTempChildMap.end() )
239 : {
240 0 : rtl::Reference< AccessibleCell > xAccessibleCell( (*iter).second );
241 0 : xAccessibleCell->setIndexInParent( nChildIndex );
242 0 : xAccessibleCell->UpdateChildren();
243 : // If row or column count is changed, there is split or merge, so all cell's acc name should be updated
244 0 : if (bRowOrColumnChanged)
245 : {
246 0 : xAccessibleCell->SetAccessibleName(xAccessibleCell->getAccessibleName(), AccessibleContextBase::ManuallySet);
247 : }
248 : // For merged cell, add invisible & disabled state.
249 0 : Reference< XMergeableCell > xMergedCell( mxTable->getCellByPosition( nCol, nRow ), UNO_QUERY );
250 0 : if (xMergedCell.is() && xMergedCell->isMerged())
251 : {
252 0 : xAccessibleCell->ResetState(AccessibleStateType::VISIBLE);
253 0 : xAccessibleCell->ResetState(AccessibleStateType::ENABLED);
254 : // IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent
255 : // xAccessibleCell->SetState(AccessibleStateType::OFFSCREEN);
256 0 : xAccessibleCell->ResetState(AccessibleStateType::SHOWING);
257 : }
258 : else
259 : {
260 0 : xAccessibleCell->SetState(AccessibleStateType::VISIBLE);
261 0 : xAccessibleCell->SetState(AccessibleStateType::ENABLED);
262 : // IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent
263 : // xAccessibleCell->ResetState(AccessibleStateType::OFFSCREEN);
264 0 : xAccessibleCell->SetState(AccessibleStateType::SHOWING);
265 : }
266 :
267 : // move still existing cell from temporary child map to our child map
268 0 : maChildMap[xCell] = xAccessibleCell;
269 0 : aTempChildMap.erase( iter );
270 : }
271 : else
272 : {
273 0 : CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) );
274 :
275 0 : rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) );
276 :
277 0 : xAccessibleCell->Init();
278 0 : maChildMap[xCell] = xAccessibleCell;
279 : }
280 :
281 0 : ++nChildIndex;
282 0 : }
283 : }
284 :
285 : // all accessible cell instances still left in aTempChildMap must be disposed
286 : // as they are no longer part of the table
287 :
288 0 : for( AccessibleCellMap::iterator iter( aTempChildMap.begin() ); iter != aTempChildMap.end(); ++iter )
289 : {
290 0 : (*iter).second->dispose();
291 : }
292 : //notify bridge to update the acc cache.
293 0 : AccessibleTableShape *pAccTable = dynamic_cast <AccessibleTableShape *> (mxAccessible.get());
294 0 : if (pAccTable)
295 0 : pAccTable->CommitChange(AccessibleEventId::INVALIDATE_ALL_CHILDREN, Any(), Any());
296 : }
297 0 : catch( const Exception& )
298 : {
299 : OSL_FAIL("svx::AccessibleTableShape::modified(), exception caught!");
300 : }
301 0 : }
302 :
303 : // XEventListener
304 0 : void SAL_CALL AccessibleTableShapeImpl::disposing( const EventObject& /*Source*/ ) throw (RuntimeException, std::exception)
305 : {
306 0 : }
307 :
308 :
309 : // AccessibleTableShape
310 :
311 :
312 :
313 :
314 0 : AccessibleTableShape::AccessibleTableShape( const AccessibleShapeInfo& rShapeInfo, const AccessibleShapeTreeInfo& rShapeTreeInfo)
315 : : AccessibleTableShape_Base(rShapeInfo, rShapeTreeInfo)
316 : , mnPreviousSelectionCount(0)
317 0 : , mxImpl( new AccessibleTableShapeImpl( maShapeTreeInfo ) )
318 : {
319 0 : }
320 :
321 :
322 :
323 0 : AccessibleTableShape::~AccessibleTableShape (void)
324 : {
325 0 : }
326 :
327 :
328 :
329 0 : void AccessibleTableShape::Init()
330 : {
331 : try
332 : {
333 0 : Reference< XPropertySet > xSet( mxShape, UNO_QUERY_THROW );
334 0 : Reference< XTable > xTable( xSet->getPropertyValue("Model"), UNO_QUERY_THROW );
335 :
336 0 : mxImpl->init( this, xTable );
337 : }
338 0 : catch( Exception& )
339 : {
340 : OSL_FAIL("AccessibleTableShape::init(), exception caught?");
341 : }
342 :
343 0 : AccessibleTableShape_Base::Init();
344 0 : }
345 :
346 :
347 :
348 0 : SvxTableController* AccessibleTableShape::getTableController()
349 : {
350 0 : SdrView* pView = maShapeTreeInfo.GetSdrView ();
351 0 : if( pView )
352 0 : return dynamic_cast< SvxTableController* >( pView->getSelectionController().get() );
353 : else
354 0 : return 0;
355 : }
356 :
357 :
358 : // XInterface
359 :
360 :
361 0 : Any SAL_CALL AccessibleTableShape::queryInterface( const Type& aType ) throw (RuntimeException, std::exception)
362 : {
363 0 : if ( aType == ::getCppuType((Reference<XAccessibleTableSelection> *)0) )
364 : {
365 0 : Reference<XAccessibleTableSelection> xThis( this );
366 0 : Any aRet;
367 0 : aRet <<= xThis;
368 0 : return aRet;
369 : }
370 : else
371 0 : return AccessibleTableShape_Base::queryInterface( aType );
372 : }
373 :
374 :
375 :
376 0 : void SAL_CALL AccessibleTableShape::acquire( ) throw ()
377 : {
378 0 : AccessibleTableShape_Base::acquire();
379 0 : }
380 :
381 :
382 :
383 0 : void SAL_CALL AccessibleTableShape::release( ) throw ()
384 : {
385 0 : AccessibleTableShape_Base::release();
386 0 : }
387 :
388 :
389 : // XAccessible
390 :
391 :
392 0 : Reference< XAccessibleContext > SAL_CALL AccessibleTableShape::getAccessibleContext(void) throw (RuntimeException, std::exception)
393 : {
394 0 : return AccessibleShape::getAccessibleContext ();
395 : }
396 :
397 :
398 0 : OUString SAL_CALL AccessibleTableShape::getImplementationName(void) throw (RuntimeException, std::exception)
399 : {
400 0 : return OUString( "com.sun.star.comp.accessibility.AccessibleTableShape" );
401 : }
402 :
403 :
404 :
405 0 : OUString AccessibleTableShape::CreateAccessibleBaseName(void) throw (RuntimeException)
406 : {
407 0 : return OUString("TableShape");
408 : }
409 :
410 :
411 :
412 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleChildCount( ) throw(RuntimeException, std::exception)
413 : {
414 0 : SolarMutexGuard aSolarGuard;
415 0 : return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() * mxImpl->mxTable->getColumnCount() : 0;
416 : }
417 :
418 :
419 0 : Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException, std::exception)
420 : {
421 0 : SolarMutexGuard aSolarGuard;
422 0 : ThrowIfDisposed();
423 :
424 0 : return mxImpl->getAccessibleChild( i );
425 : }
426 :
427 :
428 0 : Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableShape::getAccessibleRelationSet( ) throw (RuntimeException, std::exception)
429 : {
430 0 : return AccessibleShape::getAccessibleRelationSet( );
431 : }
432 :
433 :
434 :
435 0 : sal_Int16 SAL_CALL AccessibleTableShape::getAccessibleRole (void) throw (RuntimeException, std::exception)
436 : {
437 0 : return AccessibleRole::TABLE;
438 : }
439 :
440 :
441 :
442 0 : void SAL_CALL AccessibleTableShape::disposing (void)
443 : {
444 0 : mxImpl->dispose();
445 :
446 : // let the base do it's stuff
447 0 : AccessibleShape::disposing();
448 0 : }
449 :
450 :
451 : // XAccessibleTable
452 :
453 :
454 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowCount() throw (RuntimeException, std::exception)
455 : {
456 0 : SolarMutexGuard aSolarGuard;
457 0 : return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() : 0;
458 : }
459 :
460 :
461 :
462 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnCount( ) throw (RuntimeException, std::exception)
463 : {
464 0 : SolarMutexGuard aSolarGuard;
465 0 : return mxImpl->mxTable.is() ? mxImpl->mxTable->getColumnCount() : 0;
466 : }
467 :
468 :
469 :
470 0 : OUString SAL_CALL AccessibleTableShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
471 : {
472 0 : checkCellPosition( 0, nRow );
473 0 : return OUString();
474 : }
475 :
476 :
477 :
478 0 : OUString SAL_CALL AccessibleTableShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
479 : {
480 0 : SolarMutexGuard aSolarGuard;
481 0 : checkCellPosition( nColumn, 0 );
482 0 : return OUString();
483 : }
484 :
485 :
486 :
487 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
488 : {
489 0 : SolarMutexGuard aSolarGuard;
490 0 : checkCellPosition( nColumn, nRow );
491 0 : if( mxImpl->mxTable.is() )
492 : {
493 0 : Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY );
494 0 : if( xCell.is() )
495 0 : return xCell->getRowSpan();
496 : }
497 0 : return 1;
498 : }
499 :
500 :
501 :
502 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
503 : {
504 0 : SolarMutexGuard aSolarGuard;
505 0 : checkCellPosition( nColumn, nRow );
506 0 : if( mxImpl->mxTable.is() )
507 : {
508 0 : Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY );
509 0 : if( xCell.is() )
510 0 : return xCell->getColumnSpan();
511 : }
512 0 : return 1;
513 : }
514 :
515 :
516 :
517 0 : Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleRowHeaders( ) throw (RuntimeException, std::exception)
518 : {
519 0 : Reference< XAccessibleTable > xRet;
520 0 : SvxTableController* pController = getTableController();
521 0 : if( pController )
522 : {
523 0 : if( pController->isRowHeader() )
524 : {
525 0 : AccessibleTableHeaderShape* pTableHeader = new AccessibleTableHeaderShape( this, true );
526 0 : xRet.set( pTableHeader );
527 : }
528 : }
529 0 : return xRet;
530 : }
531 :
532 :
533 :
534 0 : Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleColumnHeaders( ) throw (RuntimeException, std::exception)
535 : {
536 0 : Reference< XAccessibleTable > xRet;
537 0 : SvxTableController* pController = getTableController();
538 0 : if( pController )
539 : {
540 0 : if( pController->isColumnHeader() )
541 : {
542 0 : AccessibleTableHeaderShape* pTableHeader = new AccessibleTableHeaderShape( this, false );
543 0 : xRet.set( pTableHeader );
544 : }
545 : }
546 0 : return xRet;
547 : }
548 :
549 :
550 :
551 0 : Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleRows( ) throw (RuntimeException, std::exception)
552 : {
553 0 : sal_Int32 nRow = getAccessibleRowCount();
554 0 : ::std::vector< sal_Bool > aSelected( nRow, sal_True );
555 0 : sal_Int32 nCount = nRow;
556 0 : for( sal_Int32 i = 0; i < nRow; i++ )
557 : {
558 : try
559 : {
560 0 : aSelected[i] = isAccessibleRowSelected( i );
561 : }
562 0 : catch( ... )
563 : {
564 0 : return Sequence< sal_Int32 >();
565 : }
566 :
567 0 : if( !aSelected[i] )
568 0 : nCount--;
569 : }
570 0 : Sequence < sal_Int32 > aRet( nCount );
571 0 : sal_Int32 *pRet = aRet.getArray();
572 0 : sal_Int32 nPos = 0;
573 0 : size_t nSize = aSelected.size();
574 0 : for( size_t i=0; i < nSize && nPos < nCount; i++ )
575 : {
576 0 : if( aSelected[i] )
577 : {
578 0 : *pRet++ = i;
579 0 : nPos++;
580 : }
581 : }
582 :
583 0 : return aRet;
584 : }
585 :
586 :
587 :
588 0 : Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleColumns( ) throw (RuntimeException, std::exception)
589 : {
590 0 : sal_Int32 nColumn = getAccessibleColumnCount();
591 0 : ::std::vector< sal_Bool > aSelected( nColumn, sal_True );
592 0 : sal_Int32 nCount = nColumn;
593 0 : for( sal_Int32 i = 0; i < nColumn; i++ )
594 : {
595 : try
596 : {
597 0 : aSelected[i] = isAccessibleColumnSelected( i );
598 : }
599 0 : catch( ... )
600 : {
601 0 : return Sequence< sal_Int32 >();
602 : }
603 :
604 0 : if( !aSelected[i] )
605 0 : nCount--;
606 : }
607 0 : Sequence < sal_Int32 > aRet( nCount );
608 0 : sal_Int32 *pRet = aRet.getArray();
609 0 : sal_Int32 nPos = 0;
610 0 : size_t nSize = aSelected.size();
611 0 : for( size_t i=0; i < nSize && nPos < nCount; i++ )
612 : {
613 0 : if( aSelected[i] )
614 : {
615 0 : *pRet++ = i;
616 0 : nPos++;
617 : }
618 : }
619 :
620 0 : return aRet;
621 : }
622 :
623 :
624 :
625 0 : sal_Bool SAL_CALL AccessibleTableShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
626 : {
627 0 : SolarMutexGuard aSolarGuard;
628 0 : checkCellPosition( 0, nRow );
629 0 : SvxTableController* pController = getTableController();
630 0 : if( pController )
631 : {
632 0 : return pController->isRowSelected( nRow );
633 : }
634 0 : return sal_False;
635 : }
636 :
637 :
638 :
639 0 : sal_Bool SAL_CALL AccessibleTableShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
640 : {
641 0 : SolarMutexGuard aSolarGuard;
642 0 : checkCellPosition( nColumn, 0 );
643 0 : SvxTableController* pController = getTableController();
644 0 : if( pController )
645 : {
646 0 : return pController->isColumnSelected( nColumn );
647 : }
648 0 : return sal_False;
649 : }
650 :
651 :
652 :
653 0 : Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
654 : {
655 0 : SolarMutexGuard aSolarGuard;
656 0 : checkCellPosition( nColumn, nRow );
657 :
658 0 : sal_Int32 nChildIndex = 0;
659 0 : if( mxImpl->mxTable.is() )
660 0 : nChildIndex = mxImpl->mxTable->getColumnCount() * nRow + nColumn;
661 :
662 0 : return getAccessibleChild( nChildIndex );
663 : }
664 :
665 :
666 :
667 0 : Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCaption( ) throw (RuntimeException, std::exception)
668 : {
669 0 : Reference< XAccessible > xRet;
670 0 : return xRet;
671 : }
672 :
673 :
674 :
675 0 : Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleSummary( ) throw (RuntimeException, std::exception)
676 : {
677 0 : Reference< XAccessible > xRet;
678 0 : return xRet;
679 : }
680 :
681 :
682 :
683 0 : sal_Bool SAL_CALL AccessibleTableShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
684 : {
685 0 : SolarMutexGuard aSolarGuard;
686 0 : checkCellPosition( nColumn, nRow );
687 :
688 0 : SvxTableController* pController = getTableController();
689 0 : if( pController && pController->hasSelectedCells() )
690 : {
691 0 : CellPos aFirstPos, aLastPos;
692 0 : pController->getSelectedCells( aFirstPos, aLastPos );
693 0 : if( (aFirstPos.mnRow <= nRow) && (aFirstPos.mnCol <= nColumn) && (nRow <= aLastPos.mnRow) && (nColumn <= aLastPos.mnCol) )
694 0 : return sal_True;
695 : }
696 :
697 0 : return sal_False;
698 : }
699 :
700 :
701 :
702 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
703 : {
704 0 : SolarMutexGuard aSolarGuard;
705 0 : checkCellPosition( nColumn, nRow );
706 0 : return mxImpl->mxTable.is() ? (nRow * mxImpl->mxTable->getColumnCount() + nColumn) : 0;
707 : }
708 :
709 :
710 :
711 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
712 : {
713 0 : SolarMutexGuard aSolarGuard;
714 0 : sal_Int32 nColumn = 0, nRow = 0;
715 0 : mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow );
716 0 : return nRow;
717 : }
718 :
719 :
720 :
721 0 : sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
722 : {
723 0 : SolarMutexGuard aSolarGuard;
724 0 : sal_Int32 nColumn = 0, nRow = 0;
725 0 : mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow );
726 0 : return nColumn;
727 : }
728 :
729 :
730 : // XAccessibleSelection
731 :
732 :
733 0 : void SAL_CALL AccessibleTableShape::selectAccessibleChild( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
734 : {
735 0 : SolarMutexGuard aSolarGuard;
736 0 : CellPos aPos;
737 0 : mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
738 :
739 : // todo, select table shape?!?
740 0 : SvxTableController* pController = getTableController();
741 0 : if( pController )
742 : {
743 0 : CellPos aFirstPos( aPos ), aLastPos( aPos );
744 0 : if( pController->hasSelectedCells() )
745 : {
746 0 : pController->getSelectedCells( aFirstPos, aLastPos );
747 :
748 0 : aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow );
749 0 : aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol );
750 0 : aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow );
751 0 : aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol );
752 : }
753 0 : pController->setSelectedCells( aFirstPos, aLastPos );
754 0 : }
755 0 : }
756 :
757 :
758 :
759 0 : sal_Bool SAL_CALL AccessibleTableShape::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
760 : {
761 0 : SolarMutexGuard aSolarGuard;
762 0 : CellPos aPos;
763 0 : mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
764 :
765 0 : return isAccessibleSelected(aPos.mnRow, aPos.mnCol);
766 : }
767 :
768 :
769 :
770 0 : void SAL_CALL AccessibleTableShape::clearAccessibleSelection() throw ( RuntimeException, std::exception )
771 : {
772 0 : SolarMutexGuard aSolarGuard;
773 :
774 0 : SvxTableController* pController = getTableController();
775 0 : if( pController )
776 0 : pController->clearSelection();
777 0 : }
778 :
779 :
780 0 : void SAL_CALL AccessibleTableShape::selectAllAccessibleChildren() throw ( RuntimeException, std::exception )
781 : {
782 0 : SolarMutexGuard aSolarGuard;
783 :
784 : // todo: force selection of shape?
785 0 : SvxTableController* pController = getTableController();
786 0 : if( pController )
787 0 : pController->selectAll();
788 0 : }
789 :
790 :
791 :
792 0 : sal_Int32 SAL_CALL AccessibleTableShape::getSelectedAccessibleChildCount() throw ( RuntimeException, std::exception )
793 : {
794 0 : SolarMutexGuard aSolarGuard;
795 :
796 0 : SvxTableController* pController = getTableController();
797 0 : if( pController && pController->hasSelectedCells() )
798 : {
799 0 : CellPos aFirstPos, aLastPos;
800 0 : pController->getSelectedCells( aFirstPos, aLastPos );
801 :
802 0 : const sal_Int32 nSelectedColumns = std::max( (sal_Int32)0, aLastPos.mnCol - aFirstPos.mnCol ) + 1;
803 0 : const sal_Int32 nSelectedRows = std::max( (sal_Int32)0, aLastPos.mnRow - aFirstPos.mnRow ) + 1;
804 0 : return nSelectedRows * nSelectedColumns;
805 : }
806 :
807 0 : return 0;
808 : }
809 :
810 :
811 :
812 0 : Reference< XAccessible > SAL_CALL AccessibleTableShape::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception)
813 : {
814 0 : SolarMutexGuard aSolarGuard;
815 :
816 0 : if( nSelectedChildIndex < 0 )
817 0 : throw IndexOutOfBoundsException();
818 :
819 0 : sal_Int32 nChildIndex = GetIndexOfSelectedChild( nSelectedChildIndex );
820 :
821 0 : if( nChildIndex < 0 )
822 0 : throw IndexOutOfBoundsException();
823 :
824 0 : if ( nChildIndex >= getAccessibleChildCount() )
825 : {
826 0 : throw IndexOutOfBoundsException();
827 : }
828 :
829 0 : return getAccessibleChild( nChildIndex );
830 : }
831 :
832 :
833 :
834 0 : void SAL_CALL AccessibleTableShape::deselectAccessibleChild( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
835 : {
836 0 : SolarMutexGuard aSolarGuard;
837 0 : CellPos aPos;
838 0 : mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
839 :
840 : // todo, select table shape?!?
841 0 : SvxTableController* pController = getTableController();
842 0 : if( pController && pController->hasSelectedCells() )
843 : {
844 0 : CellPos aFirstPos, aLastPos;
845 0 : pController->getSelectedCells( aFirstPos, aLastPos );
846 :
847 : // create a selection where aPos is not part of anymore
848 0 : aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow+1 );
849 0 : aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol+1 );
850 0 : aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow-1 );
851 0 : aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol-1 );
852 :
853 : // new selection may be invalid (child to deselect is not at a border of the selection but in between)
854 0 : if( (aFirstPos.mnRow > aLastPos.mnRow) || (aFirstPos.mnCol > aLastPos.mnCol) )
855 0 : pController->clearSelection(); // if selection is invalid, clear all
856 : else
857 0 : pController->setSelectedCells( aFirstPos, aLastPos );
858 0 : }
859 0 : }
860 :
861 :
862 : //===== XAccessibleTableSelection ============================================
863 0 : sal_Bool SAL_CALL AccessibleTableShape::selectRow( sal_Int32 row )
864 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
865 : {
866 0 : SolarMutexGuard aSolarGuard;
867 0 : SvxTableController* pController = getTableController();
868 0 : if( !pController )
869 0 : return sal_False;
870 0 : return pController->selectRow( row );
871 : }
872 :
873 0 : sal_Bool SAL_CALL AccessibleTableShape::selectColumn( sal_Int32 column )
874 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
875 : {
876 0 : SolarMutexGuard aSolarGuard;
877 0 : SvxTableController* pController = getTableController();
878 0 : if( !pController )
879 0 : return sal_False;
880 0 : return pController->selectColumn( column );
881 : }
882 :
883 0 : sal_Bool SAL_CALL AccessibleTableShape::unselectRow( sal_Int32 row )
884 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
885 : {
886 0 : SolarMutexGuard aSolarGuard;
887 0 : SvxTableController* pController = getTableController();
888 0 : if( !pController )
889 0 : return sal_False;
890 0 : return pController->deselectRow( row );
891 : }
892 :
893 0 : sal_Bool SAL_CALL AccessibleTableShape::unselectColumn( sal_Int32 column )
894 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
895 : {
896 0 : SolarMutexGuard aSolarGuard;
897 0 : SvxTableController* pController = getTableController();
898 0 : if( !pController )
899 0 : return sal_False;
900 0 : return pController->deselectColumn( column );
901 : }
902 :
903 0 : sal_Int32 AccessibleTableShape::GetIndexOfSelectedChild(
904 : sal_Int32 nSelectedChildIndex ) const
905 : {
906 0 : sal_Int32 nChildren = const_cast<AccessibleTableShape*>(this)->getAccessibleChildCount();
907 :
908 0 : if( nSelectedChildIndex >= nChildren )
909 0 : return -1L;
910 :
911 0 : sal_Int32 n = 0;
912 0 : while( n < nChildren )
913 : {
914 0 : if( const_cast<AccessibleTableShape*>(this)->isAccessibleChildSelected( n ) )
915 : {
916 0 : if( 0 == nSelectedChildIndex )
917 0 : break;
918 : else
919 0 : --nSelectedChildIndex;
920 : }
921 0 : ++n;
922 : }
923 :
924 0 : return n < nChildren ? n : -1L;
925 : }
926 0 : void AccessibleTableShape::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException )
927 : {
928 0 : mxImpl->getColumnAndRow(nChildIndex, rnColumn, rnRow);
929 0 : }
930 :
931 : // XSelectionChangeListener
932 : void SAL_CALL
933 0 : AccessibleTableShape::disposing (const EventObject& aEvent)
934 : throw (RuntimeException, std::exception)
935 : {
936 0 : AccessibleShape::disposing(aEvent);
937 0 : }
938 0 : void SAL_CALL AccessibleTableShape::selectionChanged (const EventObject& rEvent)
939 : throw (RuntimeException, std::exception)
940 : {
941 : //::sdr::table::CellRef xCellRef = static_cast< ::sdr::table::CellRef > (rEvent.Source);
942 0 : Reference< XCell > xCell(rEvent.Source, UNO_QUERY);
943 0 : if (xCell.is())
944 : {
945 0 : Reference< AccessibleCell > xAccCell = mxImpl->getAccessibleCell( xCell );
946 0 : if (xAccCell.is())
947 : {
948 0 : sal_Int32 nIndex = xAccCell->getAccessibleIndexInParent(),
949 0 : nCount = getSelectedAccessibleChildCount();
950 0 : sal_Bool bSelected = isAccessibleChildSelected(nIndex);
951 0 : if (mnPreviousSelectionCount == 0 && nCount > 0 && bSelected)
952 : {
953 0 : xAccCell->SetState(AccessibleStateType::SELECTED);
954 0 : xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED, Any(), Any());
955 : }
956 0 : else if (bSelected)
957 : {
958 0 : xAccCell->SetState(AccessibleStateType::SELECTED);
959 0 : xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED_ADD, Any(), Any());
960 : }
961 : else
962 : {
963 0 : xAccCell->ResetState(AccessibleStateType::SELECTED);
964 0 : xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED_REMOVE, Any(), Any());
965 : }
966 0 : mnPreviousSelectionCount = nCount;
967 0 : }
968 0 : }
969 0 : }
970 : // Get the currently active cell which is text editing
971 0 : AccessibleCell* AccessibleTableShape::GetActiveAccessibleCell()
972 : {
973 0 : sal_Bool bCellEditing = sal_False;
974 0 : Reference< AccessibleCell > xAccCell;
975 0 : AccessibleCell* pAccCell = NULL;
976 0 : SvxTableController* pController = getTableController();
977 0 : if (pController)
978 : {
979 0 : ::sdr::table::SdrTableObj* pTableObj = pController->GetTableObj();
980 0 : if ( pTableObj )
981 : {
982 0 : ::sdr::table::CellRef xCellRef (pTableObj->getActiveCell());
983 0 : if ( xCellRef.is() )
984 : {
985 0 : bCellEditing = xCellRef->IsTextEditActive();
986 0 : if (bCellEditing)
987 : {
988 : //Reference< XCell > xCell(xCellRef.get(), UNO_QUERY);
989 0 : xAccCell = mxImpl->getAccessibleCell(Reference< XCell >( xCellRef.get() ));
990 0 : if (xAccCell.is())
991 0 : pAccCell = xAccCell.get();
992 : }
993 0 : }
994 : }
995 : }
996 0 : return pAccCell;
997 : }
998 :
999 : //If current active cell is in editing, the focus state should be set to internal text
1000 0 : bool AccessibleTableShape::SetState (sal_Int16 aState)
1001 : {
1002 0 : AccessibleCell* pActiveAccessibleCell = GetActiveAccessibleCell();
1003 0 : bool bStateHasChanged = false;
1004 0 : if (aState == AccessibleStateType::FOCUSED && pActiveAccessibleCell != NULL)
1005 : {
1006 0 : return pActiveAccessibleCell->SetState(aState);
1007 : }
1008 : else
1009 0 : bStateHasChanged = AccessibleShape::SetState (aState);
1010 0 : return bStateHasChanged;
1011 : }
1012 :
1013 : //If current active cell is in editing, the focus state should be reset to internal text
1014 0 : bool AccessibleTableShape::ResetState (sal_Int16 aState)
1015 : {
1016 0 : AccessibleCell* pActiveAccessibleCell = GetActiveAccessibleCell();
1017 0 : bool bStateHasChanged = false;
1018 0 : if (aState == AccessibleStateType::FOCUSED && pActiveAccessibleCell != NULL)
1019 : {
1020 0 : return pActiveAccessibleCell->ResetState(aState);
1021 : }
1022 : else
1023 0 : bStateHasChanged = AccessibleShape::ResetState (aState);
1024 0 : return bStateHasChanged;
1025 : }
1026 :
1027 0 : bool AccessibleTableShape::SetStateDirectly (sal_Int16 aState)
1028 : {
1029 0 : return AccessibleContextBase::SetState (aState);
1030 : }
1031 :
1032 0 : bool AccessibleTableShape::ResetStateDirectly (sal_Int16 aState)
1033 : {
1034 0 : return AccessibleContextBase::ResetState (aState);
1035 : }
1036 :
1037 0 : void AccessibleTableShape::checkCellPosition( sal_Int32 nCol, sal_Int32 nRow ) throw ( IndexOutOfBoundsException )
1038 : {
1039 0 : if( (nCol >= 0) && (nRow >= 0) && mxImpl->mxTable.is() && (nCol < mxImpl->mxTable->getColumnCount()) && (nRow < mxImpl->mxTable->getRowCount()) )
1040 0 : return;
1041 :
1042 0 : throw IndexOutOfBoundsException();
1043 : }
1044 :
1045 0 : AccessibleTableHeaderShape::AccessibleTableHeaderShape( AccessibleTableShape* pTable, bool bRow )
1046 : {
1047 0 : mpTable = pTable;
1048 0 : mbRow = bRow;
1049 0 : }
1050 :
1051 0 : AccessibleTableHeaderShape::~AccessibleTableHeaderShape (void)
1052 : {
1053 0 : mpTable = NULL;
1054 0 : }
1055 :
1056 : // XAccessible
1057 0 : Reference< XAccessibleContext > SAL_CALL AccessibleTableHeaderShape::getAccessibleContext(void) throw (RuntimeException, std::exception)
1058 : {
1059 0 : return this;
1060 : }
1061 :
1062 : // XAccessibleContext
1063 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleChildCount( ) throw(RuntimeException, std::exception)
1064 : {
1065 0 : return getAccessibleRowCount() * getAccessibleColumnCount();
1066 : }
1067 :
1068 0 : Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException, std::exception)
1069 : {
1070 0 : return mpTable->getAccessibleChild( i );
1071 : }
1072 :
1073 0 : Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleParent (void) throw (RuntimeException, std::exception)
1074 : {
1075 0 : Reference< XAccessible > XParent;
1076 0 : return XParent;
1077 : }
1078 :
1079 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleIndexInParent (void) throw (RuntimeException, std::exception)
1080 : {
1081 0 : return -1;
1082 : }
1083 :
1084 0 : sal_Int16 SAL_CALL AccessibleTableHeaderShape::getAccessibleRole (void) throw (RuntimeException, std::exception)
1085 : {
1086 0 : return mpTable->getAccessibleRole();
1087 : }
1088 :
1089 0 : OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleDescription (void) throw (RuntimeException, std::exception)
1090 : {
1091 0 : return mpTable->getAccessibleDescription();
1092 : }
1093 :
1094 0 : OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleName (void) throw (RuntimeException, std::exception)
1095 : {
1096 0 : return mpTable->getAccessibleName();
1097 : }
1098 :
1099 0 : Reference< XAccessibleStateSet > SAL_CALL AccessibleTableHeaderShape::getAccessibleStateSet (void) throw (RuntimeException, std::exception)
1100 : {
1101 0 : return mpTable->getAccessibleStateSet();
1102 : }
1103 :
1104 0 : Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableHeaderShape::getAccessibleRelationSet (void) throw (RuntimeException, std::exception)
1105 : {
1106 0 : return mpTable->getAccessibleRelationSet();
1107 : }
1108 :
1109 0 : Locale SAL_CALL AccessibleTableHeaderShape::getLocale (void) throw (IllegalAccessibleComponentStateException, RuntimeException, std::exception)
1110 : {
1111 0 : return mpTable->getLocale();
1112 : }
1113 :
1114 : //XAccessibleComponent
1115 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::containsPoint ( const ::com::sun::star::awt::Point& aPoint ) throw (RuntimeException, std::exception)
1116 : {
1117 0 : return mpTable->containsPoint( aPoint );
1118 : }
1119 :
1120 0 : Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleAtPoint ( const ::com::sun::star::awt::Point& aPoint) throw (RuntimeException, std::exception)
1121 : {
1122 0 : return mpTable->getAccessibleAtPoint( aPoint );
1123 : }
1124 :
1125 0 : ::com::sun::star::awt::Rectangle SAL_CALL AccessibleTableHeaderShape::getBounds (void) throw (RuntimeException, std::exception)
1126 : {
1127 0 : return mpTable->getBounds();
1128 : }
1129 :
1130 0 : ::com::sun::star::awt::Point SAL_CALL AccessibleTableHeaderShape::getLocation (void) throw (RuntimeException, std::exception)
1131 : {
1132 0 : return mpTable->getLocation();
1133 : }
1134 :
1135 0 : ::com::sun::star::awt::Point SAL_CALL AccessibleTableHeaderShape::getLocationOnScreen (void) throw (RuntimeException, std::exception)
1136 : {
1137 0 : return mpTable->getLocationOnScreen();
1138 : }
1139 :
1140 0 : ::com::sun::star::awt::Size SAL_CALL AccessibleTableHeaderShape::getSize (void) throw (RuntimeException, std::exception)
1141 : {
1142 0 : return mpTable->getSize();
1143 : }
1144 :
1145 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getForeground (void) throw (RuntimeException, std::exception)
1146 : {
1147 0 : return mpTable->getForeground();
1148 : }
1149 :
1150 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getBackground (void) throw (RuntimeException, std::exception)
1151 : {
1152 0 : return mpTable->getBackground();
1153 : }
1154 :
1155 0 : void SAL_CALL AccessibleTableHeaderShape::grabFocus (void) throw (RuntimeException, std::exception)
1156 : {
1157 0 : mpTable->grabFocus();
1158 0 : }
1159 : //===== XAccessibleTable ============================================
1160 :
1161 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRowCount() throw (RuntimeException, std::exception)
1162 : {
1163 0 : return mbRow ? 1 : mpTable->getAccessibleRowCount();
1164 : }
1165 :
1166 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnCount() throw (RuntimeException, std::exception)
1167 : {
1168 0 : return !mbRow ? 1 : mpTable->getAccessibleColumnCount();
1169 : }
1170 :
1171 0 : OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1172 : {
1173 0 : return mpTable->getAccessibleRowDescription( nRow );
1174 : }
1175 :
1176 0 : OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1177 : {
1178 0 : return mpTable->getAccessibleColumnDescription( nColumn );
1179 : }
1180 :
1181 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1182 : {
1183 0 : return mpTable->getAccessibleRowExtentAt( nRow, nColumn );
1184 : }
1185 :
1186 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1187 : {
1188 0 : return mpTable->getAccessibleColumnExtentAt( nRow, nColumn );
1189 : }
1190 :
1191 0 : Reference< XAccessibleTable > SAL_CALL AccessibleTableHeaderShape::getAccessibleRowHeaders( ) throw (RuntimeException, std::exception)
1192 : {
1193 0 : Reference< XAccessibleTable > xRet;
1194 0 : return xRet;
1195 : }
1196 :
1197 0 : Reference< XAccessibleTable > SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnHeaders( ) throw (RuntimeException, std::exception)
1198 : {
1199 0 : Reference< XAccessibleTable > xRet;
1200 0 : return xRet;
1201 : }
1202 :
1203 0 : Sequence< sal_Int32 > SAL_CALL AccessibleTableHeaderShape::getSelectedAccessibleRows( ) throw (RuntimeException, std::exception)
1204 : {
1205 0 : sal_Int32 nRow = getAccessibleRowCount();
1206 0 : ::std::vector< sal_Bool > aSelected( nRow, sal_True );
1207 0 : sal_Int32 nCount = nRow;
1208 0 : for( sal_Int32 i = 0; i < nRow; i++ )
1209 : {
1210 : try
1211 : {
1212 0 : aSelected[i] = isAccessibleRowSelected( i );
1213 : }
1214 0 : catch( ... )
1215 : {
1216 0 : return Sequence< sal_Int32 >();
1217 : }
1218 :
1219 0 : if( !aSelected[i] )
1220 0 : nCount--;
1221 : }
1222 0 : Sequence < sal_Int32 > aRet( nCount );
1223 0 : sal_Int32 *pRet = aRet.getArray();
1224 0 : sal_Int32 nPos = 0;
1225 0 : size_t nSize = aSelected.size();
1226 0 : for( size_t i=0; i < nSize && nPos < nCount; i++ )
1227 : {
1228 0 : if( aSelected[i] )
1229 : {
1230 0 : *pRet++ = i;
1231 0 : nPos++;
1232 : }
1233 : }
1234 :
1235 0 : return aRet;
1236 : }
1237 :
1238 0 : Sequence< sal_Int32 > SAL_CALL AccessibleTableHeaderShape::getSelectedAccessibleColumns( ) throw (RuntimeException, std::exception)
1239 : {
1240 0 : sal_Int32 nColumn = getAccessibleColumnCount();
1241 0 : ::std::vector< sal_Bool > aSelected( nColumn, sal_True );
1242 0 : sal_Int32 nCount = nColumn;
1243 0 : for( sal_Int32 i = 0; i < nColumn; i++ )
1244 : {
1245 : try
1246 : {
1247 0 : aSelected[i] = isAccessibleColumnSelected( i );
1248 : }
1249 0 : catch( ... )
1250 : {
1251 0 : return Sequence< sal_Int32 >();
1252 : }
1253 :
1254 0 : if( !aSelected[i] )
1255 0 : nCount--;
1256 : }
1257 0 : Sequence < sal_Int32 > aRet( nCount );
1258 0 : sal_Int32 *pRet = aRet.getArray();
1259 0 : sal_Int32 nPos = 0;
1260 0 : size_t nSize = aSelected.size();
1261 0 : for( size_t i=0; i < nSize && nPos < nCount; i++ )
1262 : {
1263 0 : if( aSelected[i] )
1264 : {
1265 0 : *pRet++ = i;
1266 0 : nPos++;
1267 : }
1268 : }
1269 :
1270 0 : return aRet;
1271 : }
1272 :
1273 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1274 : {
1275 0 : return mpTable->isAccessibleRowSelected( nRow );
1276 : }
1277 :
1278 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1279 : {
1280 0 : return mpTable->isAccessibleColumnSelected( nColumn );
1281 : }
1282 :
1283 0 : Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1284 : {
1285 0 : return mpTable->getAccessibleCellAt( nRow, nColumn );
1286 : }
1287 :
1288 0 : Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleCaption( ) throw (RuntimeException, std::exception)
1289 : {
1290 0 : return mpTable->getAccessibleCaption();
1291 : }
1292 :
1293 0 : Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleSummary( ) throw (RuntimeException, std::exception)
1294 : {
1295 0 : return mpTable->getAccessibleSummary();
1296 : }
1297 :
1298 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1299 : {
1300 0 : return mpTable->isAccessibleSelected( nRow, nColumn );
1301 : }
1302 :
1303 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1304 : {
1305 0 : return mpTable->getAccessibleIndex( nRow, nColumn );
1306 : }
1307 :
1308 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1309 : {
1310 0 : return mpTable->getAccessibleRow( nChildIndex );
1311 : }
1312 :
1313 0 : sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1314 : {
1315 0 : return mpTable->getAccessibleColumn( nChildIndex );
1316 : }
1317 :
1318 : //===== XAccessibleTableSelection ============================================
1319 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::selectRow( sal_Int32 row )
1320 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1321 : {
1322 0 : if( mbRow )
1323 0 : return mpTable->selectRow( row );
1324 : else
1325 : {
1326 0 : mpTable->clearAccessibleSelection();
1327 0 : sal_Int32 nIndex = mpTable->getAccessibleIndex( row, 0 );
1328 0 : mpTable->selectAccessibleChild( nIndex );
1329 0 : return sal_True;
1330 : }
1331 : }
1332 :
1333 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::selectColumn( sal_Int32 column )
1334 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1335 : {
1336 0 : if( !mbRow )
1337 0 : return mpTable->selectColumn( column );
1338 : else
1339 : {
1340 0 : mpTable->clearAccessibleSelection();
1341 0 : sal_Int32 nIndex = mpTable->getAccessibleIndex( 0, column );
1342 0 : mpTable->selectAccessibleChild( nIndex );
1343 0 : return sal_True;
1344 : }
1345 : }
1346 :
1347 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::unselectRow( sal_Int32 row )
1348 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1349 : {
1350 0 : if( mbRow )
1351 0 : return mpTable->unselectRow( row );
1352 : else
1353 : {
1354 0 : sal_Int32 nIndex = mpTable->getAccessibleIndex( row, 0 );
1355 0 : mpTable->deselectAccessibleChild( nIndex );
1356 0 : return sal_True;
1357 : }
1358 : }
1359 :
1360 0 : sal_Bool SAL_CALL AccessibleTableHeaderShape::unselectColumn( sal_Int32 column )
1361 : throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1362 : {
1363 0 : if( !mbRow )
1364 0 : return mpTable->unselectColumn( column );
1365 : else
1366 : {
1367 0 : sal_Int32 nIndex = mpTable->getAccessibleIndex( 0, column );
1368 0 : mpTable->deselectAccessibleChild( nIndex );
1369 0 : return sal_True;
1370 : }
1371 : }
1372 : }
1373 :
1374 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
