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