| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include <com/sun/star/table/XMergeableCell.hpp> |
| #include <com/sun/star/accessibility/AccessibleEventId.hpp> |
| #include <com/sun/star/accessibility/AccessibleStateType.hpp> |
| |
| #include <comphelper/accessiblewrapper.hxx> |
| #include <vos/mutex.hxx> |
| #include <tools/debug.hxx> |
| #include <vcl/svapp.hxx> |
| |
| #include <svx/AccessibleTableShape.hxx> |
| #include <svx/sdr/table/tablecontroller.hxx> |
| #include "accessiblecell.hxx" |
| |
| #include <algorithm> |
| |
| #include <cppuhelper/implbase1.hxx> |
| #include <svx/svdotable.hxx> |
| #include <com/sun/star/accessibility/AccessibleStateType.hpp> |
| #include <com/sun/star/view/XSelectionSupplier.hpp> |
| |
| using ::rtl::OUString; |
| |
| using namespace ::accessibility; |
| using namespace ::sdr::table; |
| using namespace ::com::sun::star::accessibility; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::drawing; |
| using namespace ::com::sun::star::table; |
| using namespace ::com::sun::star::container; |
| |
| #define C2U(x) OUString(RTL_CONSTASCII_USTRINGPARAM(x)) |
| |
| namespace accessibility |
| { |
| |
| struct hash |
| { |
| std::size_t operator()( const Reference< XCell >& xCell ) const |
| { |
| return std::size_t( xCell.get() ); |
| } |
| }; |
| |
| typedef std::hash_map< Reference< XCell >, rtl::Reference< AccessibleCell >, hash > AccessibleCellMap; |
| |
| //----------------------------------------------------------------------------- |
| // AccessibleTableShapeImpl |
| //----------------------------------------------------------------------------- |
| |
| class AccessibleTableShapeImpl : public cppu::WeakImplHelper1< XModifyListener > |
| { |
| public: |
| AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo ); |
| |
| void init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable ); |
| void dispose(); |
| |
| Reference< XAccessible > getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException); |
| void getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException ); |
| |
| // XModifyListener |
| virtual void SAL_CALL modified( const EventObject& aEvent ) throw (RuntimeException); |
| |
| // XEventListener |
| virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException); |
| |
| AccessibleShapeTreeInfo& mrShapeTreeInfo; |
| Reference< XTable > mxTable; |
| AccessibleCellMap maChildMap; |
| Reference< XAccessible> mxAccessible; |
| sal_Int32 mRowCount, mColCount; |
| //get the cached AccessibleCell from XCell |
| Reference< AccessibleCell > getAccessibleCell (Reference< XCell > xCell); |
| }; |
| |
| //----------------------------------------------------------------------------- |
| |
| AccessibleTableShapeImpl::AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo ) |
| : mrShapeTreeInfo( rShapeTreeInfo ) |
| , mRowCount(0) |
| , mColCount(0) |
| { |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| void AccessibleTableShapeImpl::init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable ) |
| { |
| mxAccessible = xAccessible; |
| mxTable = xTable; |
| |
| if( mxTable.is() ) |
| { |
| Reference< XModifyListener > xListener( this ); |
| mxTable->addModifyListener( xListener ); |
| //register the listener with table model |
| Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(xTable, UNO_QUERY); |
| Reference< ::com::sun::star::view::XSelectionChangeListener > xSelListener( xAccessible, UNO_QUERY ); |
| if (xSelSupplier.is()) |
| xSelSupplier->addSelectionChangeListener(xSelListener); |
| mRowCount = mxTable->getRowCount(); |
| mColCount = mxTable->getColumnCount(); |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| void AccessibleTableShapeImpl::dispose() |
| { |
| if( mxTable.is() ) |
| { |
| //IAccessibility2 Implementation 2009-----, remove all the cell's acc object in table's dispose. |
| for( AccessibleCellMap::iterator iter( maChildMap.begin() ); iter != maChildMap.end(); iter++ ) |
| { |
| (*iter).second->dispose(); |
| } |
| Reference< XModifyListener > xListener( this ); |
| mxTable->removeModifyListener( xListener ); |
| mxTable.clear(); |
| } |
| mxAccessible.clear(); |
| } |
| |
| //----------------------------------------------------------------------------- |
| //IAccessibility2 Implementation 2009-----, get the cached AccessibleCell from XCell |
| Reference< AccessibleCell > AccessibleTableShapeImpl::getAccessibleCell (Reference< XCell > xCell) |
| { |
| AccessibleCellMap::iterator iter( maChildMap.find( xCell ) ); |
| |
| if( iter != maChildMap.end() ) |
| { |
| Reference< AccessibleCell > xChild( (*iter).second.get() ); |
| return xChild; |
| } |
| return Reference< AccessibleCell >(); |
| } |
| |
| //----------------------------------------------------------------------------- |
| Reference< XAccessible > AccessibleTableShapeImpl::getAccessibleChild( sal_Int32 nChildIndex ) throw(IndexOutOfBoundsException) |
| { |
| sal_Int32 nColumn = 0, nRow = 0; |
| getColumnAndRow( nChildIndex, nColumn, nRow ); |
| |
| Reference< XCell > xCell( mxTable->getCellByPosition( nColumn, nRow ) ); |
| AccessibleCellMap::iterator iter( maChildMap.find( xCell ) ); |
| |
| if( iter != maChildMap.end() ) |
| { |
| Reference< XAccessible > xChild( (*iter).second.get() ); |
| return xChild; |
| } |
| else |
| { |
| CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) ); |
| |
| rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) ); |
| |
| xAccessibleCell->Init(); |
| maChildMap[xCell] = xAccessibleCell; |
| |
| xAccessibleCell->Init(); |
| |
| Reference< XAccessible > xChild( xAccessibleCell.get() ); |
| return xChild; |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| void AccessibleTableShapeImpl::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException ) |
| { |
| rnRow = 0; |
| rnColumn = nChildIndex; |
| |
| if( mxTable.is() ) |
| { |
| const sal_Int32 nColumnCount = mxTable->getColumnCount(); |
| while( rnColumn >= nColumnCount ) |
| { |
| rnRow++; |
| rnColumn -= nColumnCount; |
| } |
| |
| if( rnRow < mxTable->getRowCount() ) |
| return; |
| } |
| |
| throw IndexOutOfBoundsException(); |
| } |
| |
| // XModifyListener |
| void SAL_CALL AccessibleTableShapeImpl::modified( const EventObject& /*aEvent*/ ) throw (RuntimeException) |
| { |
| if( mxTable.is() ) try |
| { |
| // structural changes may have happened to the table, validate all accessible cell instances |
| AccessibleCellMap aTempChildMap; |
| aTempChildMap.swap( maChildMap ); |
| |
| // first move all still existing cells to maChildMap again and update their index |
| |
| const sal_Int32 nRowCount = mxTable->getRowCount(); |
| const sal_Int32 nColCount = mxTable->getColumnCount(); |
| |
| sal_Bool bRowOrColumnChanged = sal_False; |
| if (mRowCount != nRowCount || mColCount != nColCount ) |
| { |
| bRowOrColumnChanged = sal_True; |
| mRowCount = nRowCount; |
| mColCount = nColCount; |
| } |
| sal_Int32 nChildIndex = 0; |
| |
| for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow ) |
| { |
| for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol ) |
| { |
| Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) ); |
| AccessibleCellMap::iterator iter( aTempChildMap.find( xCell ) ); |
| |
| if( iter != aTempChildMap.end() ) |
| { |
| rtl::Reference< AccessibleCell > xAccessibleCell( (*iter).second ); |
| xAccessibleCell->setIndexInParent( nChildIndex ); |
| //IAccessibility2 Implementation 2009-----, the children may need to updated |
| //xAccessibleCell->CommitChange(AccessibleEventId::VISIBLE_DATA_CHANGED, Any(), Any()); |
| xAccessibleCell->UpdateChildren(); |
| // If row or column count is changed, there is split or merge, so all cell's acc name should be updated |
| if (bRowOrColumnChanged) |
| { |
| xAccessibleCell->SetAccessibleName(xAccessibleCell->getAccessibleName(), AccessibleContextBase::ManuallySet); |
| } |
| // For merged cell, add invisible & disabled state. |
| Reference< XMergeableCell > xMergedCell( mxTable->getCellByPosition( nCol, nRow ), UNO_QUERY ); |
| if (xMergedCell.is() && xMergedCell->isMerged()) |
| { |
| xAccessibleCell->ResetState(AccessibleStateType::VISIBLE); |
| xAccessibleCell->ResetState(AccessibleStateType::ENABLED); |
| // IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent |
| // xAccessibleCell->SetState(AccessibleStateType::OFFSCREEN); |
| xAccessibleCell->ResetState(AccessibleStateType::SHOWING); |
| } |
| else |
| { |
| xAccessibleCell->SetState(AccessibleStateType::VISIBLE); |
| xAccessibleCell->SetState(AccessibleStateType::ENABLED); |
| // IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent |
| // xAccessibleCell->ResetState(AccessibleStateType::OFFSCREEN); |
| xAccessibleCell->SetState(AccessibleStateType::SHOWING); |
| } |
| |
| // move still existing cell from temporary child map to our child map |
| maChildMap[xCell] = xAccessibleCell; |
| aTempChildMap.erase( iter ); |
| } |
| //IAccessibility2 Implementation 2009-----, need to add the new added cell on demand |
| else |
| { |
| CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) ); |
| |
| rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) ); |
| |
| xAccessibleCell->Init(); |
| maChildMap[xCell] = xAccessibleCell; |
| } |
| |
| ++nChildIndex; |
| } |
| } |
| |
| // all accessible cell instances still left in aTempChildMap must be disposed |
| // as they are no longer part of the table |
| |
| for( AccessibleCellMap::iterator iter( aTempChildMap.begin() ); iter != aTempChildMap.end(); iter++ ) |
| { |
| (*iter).second->dispose(); |
| } |
| //IAccessibility2 Implementation 2009-----, notify bridge to update the acc cache. |
| AccessibleTableShape *pAccTable = dynamic_cast <AccessibleTableShape *> (mxAccessible.get()); |
| pAccTable->CommitChange(AccessibleEventId::INVALIDATE_ALL_CHILDREN, Any(), Any()); |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR("svx::AccessibleTableShape::modified(), exception caught!"); |
| } |
| } |
| |
| // XEventListener |
| void SAL_CALL AccessibleTableShapeImpl::disposing( const EventObject& /*Source*/ ) throw (RuntimeException) |
| { |
| } |
| |
| //----------------------------------------------------------------------------- |
| // AccessibleTableShape |
| //----------------------------------------------------------------------------- |
| |
| //----------------------------------------------------------------------------- |
| |
| AccessibleTableShape::AccessibleTableShape( const AccessibleShapeInfo& rShapeInfo, const AccessibleShapeTreeInfo& rShapeTreeInfo) |
| : AccessibleTableShape_Base(rShapeInfo, rShapeTreeInfo) |
| , mnPreviousSelectionCount(0) |
| , mxImpl( new AccessibleTableShapeImpl( maShapeTreeInfo ) ) |
| { |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| AccessibleTableShape::~AccessibleTableShape (void) |
| { |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| void AccessibleTableShape::Init() |
| { |
| try |
| { |
| Reference< XPropertySet > xSet( mxShape, UNO_QUERY_THROW ); |
| Reference< XTable > xTable( xSet->getPropertyValue(C2U("Model")), UNO_QUERY_THROW ); |
| |
| mxImpl->init( this, xTable ); |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR("AccessibleTableShape::init(), exception caught?"); |
| } |
| |
| AccessibleTableShape_Base::Init(); |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| SvxTableController* AccessibleTableShape::getTableController() |
| { |
| SdrView* pView = maShapeTreeInfo.GetSdrView (); |
| if( pView ) |
| return dynamic_cast< SvxTableController* >( pView->getSelectionController().get() ); |
| else |
| return 0; |
| } |
| |
| //----------------------------------------------------------------------------- |
| // XInterface |
| //----------------------------------------------------------------------------- |
| |
| Any SAL_CALL AccessibleTableShape::queryInterface( const Type& aType ) throw (RuntimeException) |
| { |
| if ( aType == ::getCppuType((Reference<XAccessibleTableSelection> *)0) ) |
| { |
| Reference<XAccessibleTableSelection> xThis( this ); |
| Any aRet; |
| aRet <<= xThis; |
| return aRet; |
| } |
| else |
| return AccessibleTableShape_Base::queryInterface( aType ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::acquire( ) throw () |
| { |
| AccessibleTableShape_Base::acquire(); |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::release( ) throw () |
| { |
| AccessibleTableShape_Base::release(); |
| } |
| |
| //----------------------------------------------------------------------------- |
| // XAccessible |
| //----------------------------------------------------------------------------- |
| |
| Reference< XAccessibleContext > SAL_CALL AccessibleTableShape::getAccessibleContext(void) throw (RuntimeException) |
| { |
| return AccessibleShape::getAccessibleContext (); |
| } |
| |
| //----------------------------------------------------------------------------- |
| OUString SAL_CALL AccessibleTableShape::getImplementationName(void) throw (RuntimeException) |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.accessibility.AccessibleTableShape" ) ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| OUString AccessibleTableShape::CreateAccessibleBaseName(void) throw (RuntimeException) |
| { |
| return OUString (RTL_CONSTASCII_USTRINGPARAM("TableShape")); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleChildCount( ) throw(RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard(::Application::GetSolarMutex()); |
| return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() * mxImpl->mxTable->getColumnCount() : 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| ThrowIfDisposed(); |
| |
| return mxImpl->getAccessibleChild( i ); |
| } |
| |
| //-------------------------------------------------------------------- |
| Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableShape::getAccessibleRelationSet( ) throw (RuntimeException) |
| { |
| return AccessibleShape::getAccessibleRelationSet( ); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int16 SAL_CALL AccessibleTableShape::getAccessibleRole (void) throw (RuntimeException) |
| { |
| return AccessibleRole::TABLE; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::disposing (void) |
| { |
| mxImpl->dispose(); |
| |
| // let the base do it's stuff |
| AccessibleShape::disposing(); |
| } |
| |
| //-------------------------------------------------------------------- |
| // XAccessibleTable |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowCount() throw (RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() : 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnCount( ) throw (RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| return mxImpl->mxTable.is() ? mxImpl->mxTable->getColumnCount() : 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| OUString SAL_CALL AccessibleTableShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| checkCellPosition( 0, nRow ); |
| return OUString(); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| OUString SAL_CALL AccessibleTableShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, 0 ); |
| return OUString(); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, nRow ); |
| if( mxImpl->mxTable.is() ) |
| { |
| Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY ); |
| if( xCell.is() ) |
| return xCell->getRowSpan(); |
| } |
| return 1; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, nRow ); |
| if( mxImpl->mxTable.is() ) |
| { |
| Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY ); |
| if( xCell.is() ) |
| return xCell->getColumnSpan(); |
| } |
| return 1; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleRowHeaders( ) throw (RuntimeException) |
| { |
| //Reference< XAccessibleTable > xRet( this ); // todo |
| Reference< XAccessibleTable > xRet; |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| { |
| if( pController->isRowHeader() ) |
| { |
| AccessibleTableHeaderShape* pTableHeader = new AccessibleTableHeaderShape( this, sal_True ); |
| xRet.set( pTableHeader ); |
| } |
| } |
| return xRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleColumnHeaders( ) throw (RuntimeException) |
| { |
| //Reference< XAccessibleTable > xRet( this ); // todo |
| Reference< XAccessibleTable > xRet; |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| { |
| if( pController->isColumnHeader() ) |
| { |
| AccessibleTableHeaderShape* pTableHeader = new AccessibleTableHeaderShape( this, sal_False ); |
| xRet.set( pTableHeader ); |
| } |
| } |
| return xRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleRows( ) throw (RuntimeException) |
| { |
| /*Sequence< sal_Int32 > aRet;*/ |
| sal_Int32 nRow = getAccessibleRowCount(); |
| ::std::vector< sal_Bool > aSelected( nRow, sal_True ); |
| sal_Int32 nCount = nRow; |
| for( sal_Int32 i = 0; i < nRow; i++ ) |
| { |
| try |
| { |
| aSelected[i] = isAccessibleRowSelected( i ); |
| } |
| catch( ... ) |
| { |
| return Sequence< sal_Int32 >(); |
| } |
| |
| if( !aSelected[i] ) |
| nCount--; |
| } |
| Sequence < sal_Int32 > aRet( nCount ); |
| sal_Int32 *pRet = aRet.getArray(); |
| sal_Int32 nPos = 0; |
| size_t nSize = aSelected.size(); |
| for( size_t i=0; i < nSize && nPos < nCount; i++ ) |
| { |
| if( aSelected[i] ) |
| { |
| *pRet++ = i; |
| nPos++; |
| } |
| } |
| |
| return aRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleColumns( ) throw (RuntimeException) |
| { |
| /*Sequence< sal_Int32 > aRet;*/ |
| sal_Int32 nColumn = getAccessibleColumnCount(); |
| ::std::vector< sal_Bool > aSelected( nColumn, sal_True ); |
| sal_Int32 nCount = nColumn; |
| for( sal_Int32 i = 0; i < nColumn; i++ ) |
| { |
| try |
| { |
| aSelected[i] = isAccessibleColumnSelected( i ); |
| } |
| catch( ... ) |
| { |
| return Sequence< sal_Int32 >(); |
| } |
| |
| if( !aSelected[i] ) |
| nCount--; |
| } |
| Sequence < sal_Int32 > aRet( nCount ); |
| sal_Int32 *pRet = aRet.getArray(); |
| sal_Int32 nPos = 0; |
| size_t nSize = aSelected.size(); |
| for( size_t i=0; i < nSize && nPos < nCount; i++ ) |
| { |
| if( aSelected[i] ) |
| { |
| *pRet++ = i; |
| nPos++; |
| } |
| } |
| |
| return aRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL AccessibleTableShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( 0, nRow ); |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| { |
| return pController->isRowSelected( nRow ); |
| } |
| return sal_False; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL AccessibleTableShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, 0 ); |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| { |
| return pController->isColumnSelected( nColumn ); |
| } |
| return sal_False; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, nRow ); |
| |
| sal_Int32 nChildIndex = 0; |
| if( mxImpl->mxTable.is() ) |
| nChildIndex = mxImpl->mxTable->getColumnCount() * nRow + nColumn; |
| |
| return getAccessibleChild( nChildIndex ); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCaption( ) throw (RuntimeException) |
| { |
| Reference< XAccessible > xRet; |
| return xRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleSummary( ) throw (RuntimeException) |
| { |
| Reference< XAccessible > xRet; |
| return xRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL AccessibleTableShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, nRow ); |
| |
| SvxTableController* pController = getTableController(); |
| if( pController && pController->hasSelectedCells() ) |
| { |
| CellPos aFirstPos, aLastPos; |
| pController->getSelectedCells( aFirstPos, aLastPos ); |
| if( (aFirstPos.mnRow <= nRow) && (aFirstPos.mnCol <= nColumn) && (nRow <= aLastPos.mnRow) && (nColumn <= aLastPos.mnCol) ) |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| checkCellPosition( nColumn, nRow ); |
| return mxImpl->mxTable.is() ? (nRow * mxImpl->mxTable->getColumnCount() + nColumn) : 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| sal_Int32 nColumn = 0, nRow = 0; |
| mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow ); |
| return nRow; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| sal_Int32 nColumn = 0, nRow = 0; |
| mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow ); |
| //return nChildIndex; |
| return nColumn; |
| } |
| |
| //-------------------------------------------------------------------- |
| // XAccessibleSelection |
| //-------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::selectAccessibleChild( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException ) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| CellPos aPos; |
| mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow ); |
| |
| // todo, select table shape?!? |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| { |
| CellPos aFirstPos( aPos ), aLastPos( aPos ); |
| if( pController->hasSelectedCells() ) |
| { |
| pController->getSelectedCells( aFirstPos, aLastPos ); |
| |
| aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow ); |
| aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol ); |
| aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow ); |
| aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol ); |
| } |
| pController->setSelectedCells( aFirstPos, aLastPos ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL AccessibleTableShape::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException ) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| CellPos aPos; |
| mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow ); |
| |
| // Para order is not correct |
| //return isAccessibleSelected(aPos.mnCol, aPos.mnRow); |
| return isAccessibleSelected(aPos.mnRow, aPos.mnCol); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::clearAccessibleSelection() throw ( RuntimeException ) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| pController->clearSelection(); |
| } |
| //-------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::selectAllAccessibleChildren() throw ( RuntimeException ) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| |
| // todo: force selection of shape? |
| SvxTableController* pController = getTableController(); |
| if( pController ) |
| pController->selectAll(); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL AccessibleTableShape::getSelectedAccessibleChildCount() throw ( RuntimeException ) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| |
| SvxTableController* pController = getTableController(); |
| if( pController && pController->hasSelectedCells() ) |
| { |
| CellPos aFirstPos, aLastPos; |
| pController->getSelectedCells( aFirstPos, aLastPos ); |
| |
| const sal_Int32 nSelectedColumns = std::max( (sal_Int32)0, aLastPos.mnCol - aFirstPos.mnCol ) + 1; |
| const sal_Int32 nSelectedRows = std::max( (sal_Int32)0, aLastPos.mnRow - aFirstPos.mnRow ) + 1; |
| return nSelectedRows * nSelectedColumns; |
| } |
| |
| return 0; |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableShape::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| |
| /*SvxTableController* pController = getTableController(); |
| if( pController && pController->hasSelectedCells() ) |
| { |
| CellPos aFirstPos, aLastPos; |
| pController->getSelectedCells( aFirstPos, aLastPos ); |
| |
| const sal_Int32 nSelectedColumns = std::max( (sal_Int32)0, aLastPos.mnCol - aFirstPos.mnCol ) + 1; |
| const sal_Int32 nSelectedRows = std::max( (sal_Int32)0, aLastPos.mnRow - aFirstPos.mnRow ) + 1; |
| |
| if( nSelectedChildIndex < (nSelectedRows * nSelectedColumns) ) |
| { |
| while( nSelectedChildIndex >= nSelectedColumns ) |
| { |
| aFirstPos.mnRow++; |
| nSelectedChildIndex -= nSelectedColumns; |
| } |
| return getAccessibleCellAt( nSelectedColumns, aFirstPos.mnRow ); |
| } |
| } |
| |
| throw IndexOutOfBoundsException(); |
| */ |
| if( nSelectedChildIndex < 0 ) |
| throw IndexOutOfBoundsException(); |
| |
| sal_Int32 nChildIndex = GetIndexOfSelectedChild( nSelectedChildIndex ); |
| |
| if( nChildIndex < 0 ) |
| throw IndexOutOfBoundsException(); |
| |
| if ( nChildIndex >= getAccessibleChildCount() ) |
| { |
| throw IndexOutOfBoundsException(); |
| } |
| |
| return getAccessibleChild( nChildIndex ); |
| } |
| |
| //-------------------------------------------------------------------- |
| |
| void SAL_CALL AccessibleTableShape::deselectAccessibleChild( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException ) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| CellPos aPos; |
| mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow ); |
| |
| // todo, select table shape?!? |
| SvxTableController* pController = getTableController(); |
| if( pController && pController->hasSelectedCells() ) |
| { |
| CellPos aFirstPos, aLastPos; |
| pController->getSelectedCells( aFirstPos, aLastPos ); |
| |
| // create a selection where aPos is not part of anymore |
| aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow+1 ); |
| aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol+1 ); |
| aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow-1 ); |
| aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol-1 ); |
| |
| // new selection may be invalid (child to deselect is not at a border of the selection but in between) |
| if( (aFirstPos.mnRow > aLastPos.mnRow) || (aFirstPos.mnCol > aLastPos.mnCol) ) |
| pController->clearSelection(); // if selection is invalid, clear all |
| else |
| pController->setSelectedCells( aFirstPos, aLastPos ); |
| } |
| } |
| //-------------------------------------------------------------------- |
| |
| //===== XAccessibleTableSelection ============================================ |
| sal_Bool SAL_CALL AccessibleTableShape::selectRow( sal_Int32 row ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| SvxTableController* pController = getTableController(); |
| if( !pController ) |
| return sal_False; |
| return pController->selectRow( row ); |
| } |
| sal_Bool SAL_CALL AccessibleTableShape::selectColumn( sal_Int32 column ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| SvxTableController* pController = getTableController(); |
| if( !pController ) |
| return sal_False; |
| return pController->selectColumn( column ); |
| } |
| sal_Bool SAL_CALL AccessibleTableShape::unselectRow( sal_Int32 row ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| SvxTableController* pController = getTableController(); |
| if( !pController ) |
| return sal_False; |
| return pController->deselectRow( row ); |
| } |
| sal_Bool SAL_CALL AccessibleTableShape::unselectColumn( sal_Int32 column ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); |
| SvxTableController* pController = getTableController(); |
| if( !pController ) |
| return sal_False; |
| return pController->deselectColumn( column ); |
| } |
| sal_Int32 AccessibleTableShape::GetIndexOfSelectedChild( |
| sal_Int32 nSelectedChildIndex ) const |
| { |
| sal_Int32 nChildren = const_cast<AccessibleTableShape*>(this)->getAccessibleChildCount(); |
| |
| if( nSelectedChildIndex >= nChildren ) |
| return -1L; |
| |
| sal_Int32 n = 0; |
| while( n < nChildren ) |
| { |
| if( const_cast<AccessibleTableShape*>(this)->isAccessibleChildSelected( n ) ) |
| { |
| if( 0 == nSelectedChildIndex ) |
| break; |
| else |
| --nSelectedChildIndex; |
| } |
| ++n; |
| } |
| |
| return n < nChildren ? n : -1L; |
| } |
| void AccessibleTableShape::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException ) |
| { |
| mxImpl->getColumnAndRow(nChildIndex, rnColumn, rnRow); |
| } |
| //-------------------------------------------------------------------- |
| // XSelectionChangeListener |
| void SAL_CALL |
| AccessibleTableShape::disposing (const EventObject& aEvent) |
| throw (RuntimeException) |
| { |
| AccessibleShape::disposing(aEvent); |
| } |
| void SAL_CALL AccessibleTableShape::selectionChanged (const EventObject& rEvent) |
| throw (RuntimeException) |
| { |
| //::sdr::table::CellRef xCellRef = static_cast< ::sdr::table::CellRef > (rEvent.Source); |
| Reference< XCell > xCell(rEvent.Source, UNO_QUERY); |
| if (xCell.is()) |
| { |
| Reference< AccessibleCell > xAccCell = mxImpl->getAccessibleCell( xCell ); |
| if (xAccCell.is()) |
| { |
| sal_Int32 nIndex = xAccCell->getAccessibleIndexInParent(), |
| nCount = getSelectedAccessibleChildCount(); |
| sal_Bool bSelected = isAccessibleChildSelected(nIndex); |
| if (mnPreviousSelectionCount == 0 && nCount > 0 && bSelected) |
| { |
| xAccCell->SetState(AccessibleStateType::SELECTED); |
| xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED, Any(), Any()); |
| } |
| else if (bSelected) |
| { |
| xAccCell->SetState(AccessibleStateType::SELECTED); |
| xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED_ADD, Any(), Any()); |
| } |
| else |
| { |
| xAccCell->ResetState(AccessibleStateType::SELECTED); |
| xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED_REMOVE, Any(), Any()); |
| } |
| mnPreviousSelectionCount = nCount; |
| } |
| } |
| } |
| // Get the currently active cell which is text editing |
| AccessibleCell* AccessibleTableShape::GetActiveAccessibleCell() |
| { |
| sal_Bool bCellEditing = sal_False; |
| Reference< AccessibleCell > xAccCell; |
| AccessibleCell* pAccCell = NULL; |
| SvxTableController* pController = getTableController(); |
| if (pController) |
| { |
| ::sdr::table::SdrTableObj* pTableObj = pController->GetTableObj(); |
| if ( pTableObj ) |
| { |
| ::sdr::table::CellRef xCellRef (pTableObj->getActiveCell()); |
| if ( xCellRef.is() ) |
| { |
| bCellEditing = xCellRef->IsTextEditActive(); |
| if (bCellEditing) |
| { |
| //Reference< XCell > xCell(xCellRef.get(), UNO_QUERY); |
| xAccCell = mxImpl->getAccessibleCell(Reference< XCell >( xCellRef.get() )); |
| if (xAccCell.is()) |
| pAccCell = xAccCell.get(); |
| } |
| } |
| } |
| } |
| return pAccCell; |
| } |
| //-------------------------------------------------------------------- |
| //If current active cell is in editing, the focus state should be set to internal text |
| sal_Bool AccessibleTableShape::SetState (sal_Int16 aState) |
| { |
| AccessibleCell* pActiveAccessibleCell = GetActiveAccessibleCell(); |
| sal_Bool bStateHasChanged = sal_False; |
| if (aState == AccessibleStateType::FOCUSED && pActiveAccessibleCell != NULL) |
| { |
| return pActiveAccessibleCell->SetState(aState); |
| } |
| else |
| bStateHasChanged = AccessibleShape::SetState (aState); |
| return bStateHasChanged; |
| } |
| //-------------------------------------------------------------------- |
| //If current active cell is in editing, the focus state should be reset to internal text |
| sal_Bool AccessibleTableShape::ResetState (sal_Int16 aState) |
| { |
| AccessibleCell* pActiveAccessibleCell = GetActiveAccessibleCell(); |
| sal_Bool bStateHasChanged = sal_False; |
| if (aState == AccessibleStateType::FOCUSED && pActiveAccessibleCell != NULL) |
| { |
| return pActiveAccessibleCell->ResetState(aState); |
| } |
| else |
| bStateHasChanged = AccessibleShape::ResetState (aState); |
| return bStateHasChanged; |
| } |
| //-------------------------------------------------------------------- |
| sal_Bool AccessibleTableShape::SetStateDirectly (sal_Int16 aState) |
| { |
| return AccessibleContextBase::SetState (aState); |
| } |
| //-------------------------------------------------------------------- |
| sal_Bool AccessibleTableShape::ResetStateDirectly (sal_Int16 aState) |
| { |
| return AccessibleContextBase::ResetState (aState); |
| } |
| void AccessibleTableShape::checkCellPosition( sal_Int32 nCol, sal_Int32 nRow ) throw ( IndexOutOfBoundsException ) |
| { |
| if( (nCol >= 0) && (nRow >= 0) && mxImpl->mxTable.is() && (nCol < mxImpl->mxTable->getColumnCount()) && (nRow < mxImpl->mxTable->getRowCount()) ) |
| return; |
| |
| throw IndexOutOfBoundsException(); |
| } |
| |
| AccessibleTableHeaderShape::AccessibleTableHeaderShape( AccessibleTableShape* pTable, sal_Bool bRow ) |
| { |
| mpTable = pTable; |
| mbRow = bRow; |
| } |
| |
| AccessibleTableHeaderShape::~AccessibleTableHeaderShape (void) |
| { |
| mpTable = NULL; |
| } |
| |
| // XAccessible |
| Reference< XAccessibleContext > SAL_CALL AccessibleTableHeaderShape::getAccessibleContext(void) throw (RuntimeException) |
| { |
| return this; |
| } |
| |
| // XAccessibleContext |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleChildCount( ) throw(RuntimeException) |
| { |
| return getAccessibleRowCount() * getAccessibleColumnCount(); |
| } |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleChild( i ); |
| } |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleParent (void) throw (RuntimeException) |
| { |
| Reference< XAccessible > XParent; |
| return XParent; |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleIndexInParent (void) throw (RuntimeException) |
| { |
| return -1; |
| } |
| |
| sal_Int16 SAL_CALL AccessibleTableHeaderShape::getAccessibleRole (void) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleRole(); |
| } |
| |
| OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleDescription (void) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleDescription(); |
| } |
| |
| OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleName (void) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleName(); |
| } |
| |
| Reference< XAccessibleStateSet > SAL_CALL AccessibleTableHeaderShape::getAccessibleStateSet (void) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleStateSet(); |
| } |
| |
| Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableHeaderShape::getAccessibleRelationSet (void) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleRelationSet(); |
| } |
| |
| Locale SAL_CALL AccessibleTableHeaderShape::getLocale (void) throw (IllegalAccessibleComponentStateException, RuntimeException) |
| { |
| return mpTable->getLocale(); |
| } |
| |
| //XAccessibleComponent |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::containsPoint ( const ::com::sun::star::awt::Point& aPoint ) throw (RuntimeException) |
| { |
| return mpTable->containsPoint( aPoint ); |
| } |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleAtPoint ( const ::com::sun::star::awt::Point& aPoint) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleAtPoint( aPoint ); |
| } |
| |
| ::com::sun::star::awt::Rectangle SAL_CALL AccessibleTableHeaderShape::getBounds (void) throw (RuntimeException) |
| { |
| return mpTable->getBounds(); |
| } |
| |
| ::com::sun::star::awt::Point SAL_CALL AccessibleTableHeaderShape::getLocation (void) throw (RuntimeException) |
| { |
| return mpTable->getLocation(); |
| } |
| |
| ::com::sun::star::awt::Point SAL_CALL AccessibleTableHeaderShape::getLocationOnScreen (void) throw (RuntimeException) |
| { |
| return mpTable->getLocationOnScreen(); |
| } |
| |
| ::com::sun::star::awt::Size SAL_CALL AccessibleTableHeaderShape::getSize (void) throw (RuntimeException) |
| { |
| return mpTable->getSize(); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getForeground (void) throw (RuntimeException) |
| { |
| return mpTable->getForeground(); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getBackground (void) throw (RuntimeException) |
| { |
| return mpTable->getBackground(); |
| } |
| |
| void SAL_CALL AccessibleTableHeaderShape::grabFocus (void) throw (RuntimeException) |
| { |
| mpTable->grabFocus(); |
| } |
| //===== XAccessibleTable ============================================ |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRowCount() throw (RuntimeException) |
| { |
| return mbRow ? 1 : mpTable->getAccessibleRowCount(); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnCount() throw (RuntimeException) |
| { |
| return !mbRow ? 1 : mpTable->getAccessibleColumnCount(); |
| } |
| |
| OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleRowDescription( nRow ); |
| } |
| |
| OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleColumnDescription( nColumn ); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleRowExtentAt( nRow, nColumn ); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleColumnExtentAt( nRow, nColumn ); |
| } |
| |
| Reference< XAccessibleTable > SAL_CALL AccessibleTableHeaderShape::getAccessibleRowHeaders( ) throw (RuntimeException) |
| { |
| Reference< XAccessibleTable > xRet; |
| return xRet; |
| } |
| |
| Reference< XAccessibleTable > SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnHeaders( ) throw (RuntimeException) |
| { |
| Reference< XAccessibleTable > xRet; |
| return xRet; |
| } |
| |
| Sequence< sal_Int32 > SAL_CALL AccessibleTableHeaderShape::getSelectedAccessibleRows( ) throw (RuntimeException) |
| { |
| sal_Int32 nRow = getAccessibleRowCount(); |
| ::std::vector< sal_Bool > aSelected( nRow, sal_True ); |
| sal_Int32 nCount = nRow; |
| for( sal_Int32 i = 0; i < nRow; i++ ) |
| { |
| try |
| { |
| aSelected[i] = isAccessibleRowSelected( i ); |
| } |
| catch( ... ) |
| { |
| return Sequence< sal_Int32 >(); |
| } |
| |
| if( !aSelected[i] ) |
| nCount--; |
| } |
| Sequence < sal_Int32 > aRet( nCount ); |
| sal_Int32 *pRet = aRet.getArray(); |
| sal_Int32 nPos = 0; |
| size_t nSize = aSelected.size(); |
| for( size_t i=0; i < nSize && nPos < nCount; i++ ) |
| { |
| if( aSelected[i] ) |
| { |
| *pRet++ = i; |
| nPos++; |
| } |
| } |
| |
| return aRet; |
| } |
| |
| Sequence< sal_Int32 > SAL_CALL AccessibleTableHeaderShape::getSelectedAccessibleColumns( ) throw (RuntimeException) |
| { |
| sal_Int32 nColumn = getAccessibleColumnCount(); |
| ::std::vector< sal_Bool > aSelected( nColumn, sal_True ); |
| sal_Int32 nCount = nColumn; |
| for( sal_Int32 i = 0; i < nColumn; i++ ) |
| { |
| try |
| { |
| aSelected[i] = isAccessibleColumnSelected( i ); |
| } |
| catch( ... ) |
| { |
| return Sequence< sal_Int32 >(); |
| } |
| |
| if( !aSelected[i] ) |
| nCount--; |
| } |
| Sequence < sal_Int32 > aRet( nCount ); |
| sal_Int32 *pRet = aRet.getArray(); |
| sal_Int32 nPos = 0; |
| size_t nSize = aSelected.size(); |
| for( size_t i=0; i < nSize && nPos < nCount; i++ ) |
| { |
| if( aSelected[i] ) |
| { |
| *pRet++ = i; |
| nPos++; |
| } |
| } |
| |
| return aRet; |
| } |
| |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->isAccessibleRowSelected( nRow ); |
| } |
| |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->isAccessibleColumnSelected( nColumn ); |
| } |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleCellAt( nRow, nColumn ); |
| } |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleCaption( ) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleCaption(); |
| } |
| |
| Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleSummary( ) throw (RuntimeException) |
| { |
| return mpTable->getAccessibleSummary(); |
| } |
| |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->isAccessibleSelected( nRow, nColumn ); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleIndex( nRow, nColumn ); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleRow( nChildIndex ); |
| } |
| |
| sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| return mpTable->getAccessibleColumn( nChildIndex ); |
| } |
| |
| //===== XAccessibleTableSelection ============================================ |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::selectRow( sal_Int32 row ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| if( mbRow ) |
| return mpTable->selectRow( row ); |
| else |
| { |
| mpTable->clearAccessibleSelection(); |
| sal_Int32 nIndex = mpTable->getAccessibleIndex( row, 0 ); |
| mpTable->selectAccessibleChild( nIndex ); |
| return sal_True; |
| } |
| } |
| |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::selectColumn( sal_Int32 column ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| if( !mbRow ) |
| return mpTable->selectColumn( column ); |
| else |
| { |
| mpTable->clearAccessibleSelection(); |
| sal_Int32 nIndex = mpTable->getAccessibleIndex( 0, column ); |
| mpTable->selectAccessibleChild( nIndex ); |
| return sal_True; |
| } |
| } |
| |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::unselectRow( sal_Int32 row ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| if( mbRow ) |
| return mpTable->unselectRow( row ); |
| else |
| { |
| sal_Int32 nIndex = mpTable->getAccessibleIndex( row, 0 ); |
| mpTable->deselectAccessibleChild( nIndex ); |
| return sal_True; |
| } |
| } |
| |
| sal_Bool SAL_CALL AccessibleTableHeaderShape::unselectColumn( sal_Int32 column ) |
| throw (IndexOutOfBoundsException, RuntimeException) |
| { |
| if( !mbRow ) |
| return mpTable->unselectColumn( column ); |
| else |
| { |
| sal_Int32 nIndex = mpTable->getAccessibleIndex( 0, column ); |
| mpTable->deselectAccessibleChild( nIndex ); |
| return sal_True; |
| } |
| } |
| } |
