diff options
Diffstat (limited to 'sw/source/core/access/acctable.cxx')
-rw-r--r-- | sw/source/core/access/acctable.cxx | 1755 |
1 files changed, 1755 insertions, 0 deletions
diff --git a/sw/source/core/access/acctable.cxx b/sw/source/core/access/acctable.cxx new file mode 100644 index 000000000000..ba843fb22715 --- /dev/null +++ b/sw/source/core/access/acctable.cxx @@ -0,0 +1,1755 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + /************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sw.hxx" +#include <osl/mutex.hxx> +#include <rtl/uuid.h> +#include <rtl/ustrbuf.hxx> + +#include <list> +#include <set> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleTableModelChange.hpp> +#include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <vcl/svapp.hxx> +#include <frmfmt.hxx> +#include <tabfrm.hxx> +#include <rowfrm.hxx> +#include <cellfrm.hxx> +#include <swtable.hxx> +#include <crsrsh.hxx> +#include <viscrs.hxx> +#include <hints.hxx> +#include <fesh.hxx> +#include <accfrmobjslist.hxx> +#include <accmap.hxx> +#include <access.hrc> +#include <acctable.hxx> + +#include <com/sun/star/accessibility/XAccessibleText.hpp> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; +using ::rtl::OUString; +using ::rtl::OUStringBuffer; +using namespace ::sw::access; + +const sal_Char sServiceName[] = "com.sun.star.table.AccessibleTableView"; +const sal_Char sImplementationName[] = "com.sun.star.comp.Writer.SwAccessibleTableView"; + +typedef ::std::less < sal_Int32 > Int32Less_Impl; +typedef ::std::set < sal_Int32, Int32Less_Impl > Int32Set_Impl; + +typedef ::std::pair < sal_Int32, sal_Int32 > Int32Pair_Impl; +typedef ::std::list < Int32Pair_Impl > Int32PairList_Impl; + +class SwAccTableSelHander_Impl +{ +public: + virtual void Unselect( sal_Int32 nRowOrCol, sal_Int32 nExt ) = 0; +}; + + +//------------------------------------------------------------------------------ + +class SwAccessibleTableData_Impl +{ + SwAccessibleMap& mrAccMap; + Int32Set_Impl maRows; + Int32Set_Impl maColumns; + Int32PairList_Impl maExtents; // cell extends for event processing only + Point maTabFrmPos; + const SwTabFrm *mpTabFrm; + sal_Bool mbIsInPagePreview; + bool mbOnlyTableColumnHeader; + + void CollectData( const SwFrm *pFrm ); + void CollectExtents( const SwFrm *pFrm ); + + sal_Bool FindCell( const Point& rPos, const SwFrm *pFrm , + sal_Bool bExact, const SwFrm *& rFrm ) const; + + void GetSelection( const Point& rTabPos, const SwRect& rArea, + const SwSelBoxes& rSelBoxes, const SwFrm *pFrm, + SwAccTableSelHander_Impl& rSelHdl, + sal_Bool bColumns ) const; + + // #i77106# + inline bool IncludeRow( const SwFrm& rFrm ) const + { + return !mbOnlyTableColumnHeader || + mpTabFrm->IsInHeadline( rFrm ); + } + // <-- +public: + // #i77106# - add third optional parameter <bOnlyTableColumnHeader>, default value <false> + SwAccessibleTableData_Impl( SwAccessibleMap& rAccMap, + const SwTabFrm *pTabFrm, + sal_Bool bIsInPagePreview, + bool bOnlyTableColumnHeader = false ); + // <-- + + const Int32Set_Impl& GetRows() const { return maRows; } + const Int32Set_Impl& GetColumns() const { return maColumns; } + + inline Int32Set_Impl::const_iterator GetRowIter( sal_Int32 nRow ) const; + inline Int32Set_Impl::const_iterator GetColumnIter( sal_Int32 nCol ) const; + + const SwFrm *GetCell( sal_Int32 nRow, sal_Int32 nColumn, sal_Bool bExact, + SwAccessibleTable *pThis ) const + throw(lang::IndexOutOfBoundsException ); + const SwFrm *GetCellAtPos( sal_Int32 nLeft, sal_Int32 nTop, + sal_Bool bExact ) const; + inline sal_Int32 GetRowCount() const; + inline sal_Int32 GetColumnCount() const; + sal_Bool CompareExtents( const SwAccessibleTableData_Impl& r ) const; + + void GetSelection( sal_Int32 nStart, sal_Int32 nEnd, + const SwSelBoxes& rSelBoxes, + SwAccTableSelHander_Impl& rSelHdl, + sal_Bool bColumns ) const; + + void CheckRowAndCol( sal_Int32 nRow, sal_Int32 nCol, + SwAccessibleTable *pThis ) const + throw(lang::IndexOutOfBoundsException ); + + void GetRowColumnAndExtent( const SwRect& rBox, + sal_Int32& rRow, sal_Int32& rColumn, + sal_Int32& rRowExtent, + sal_Int32& rColumnExtent ) const; + + const Point& GetTablePos() const { return maTabFrmPos; } + void SetTablePos( const Point& rPos ) { maTabFrmPos = rPos; } +}; + +void SwAccessibleTableData_Impl::CollectData( const SwFrm *pFrm ) +{ + const SwAccessibleChildSList aList( *pFrm, mrAccMap ); + SwAccessibleChildSList::const_iterator aIter( aList.begin() ); + SwAccessibleChildSList::const_iterator aEndIter( aList.end() ); + while( aIter != aEndIter ) + { + const SwAccessibleChild& rLower = *aIter; + const SwFrm *pLower = rLower.GetSwFrm(); + if( pLower ) + { + if( pLower->IsRowFrm() ) + { + // #i77106# + if ( IncludeRow( *pLower ) ) + { + maRows.insert( pLower->Frm().Top() - maTabFrmPos.Y() ); + CollectData( pLower ); + } + } + else if( pLower->IsCellFrm() && + rLower.IsAccessible( mbIsInPagePreview ) ) + { + maColumns.insert( pLower->Frm().Left() - maTabFrmPos.X() ); + } + else + { + CollectData( pLower ); + } + } + ++aIter; + } +} + +void SwAccessibleTableData_Impl::CollectExtents( const SwFrm *pFrm ) +{ + const SwAccessibleChildSList aList( *pFrm, mrAccMap ); + SwAccessibleChildSList::const_iterator aIter( aList.begin() ); + SwAccessibleChildSList::const_iterator aEndIter( aList.end() ); + while( aIter != aEndIter ) + { + const SwAccessibleChild& rLower = *aIter; + const SwFrm *pLower = rLower.GetSwFrm(); + if( pLower ) + { + if( pLower->IsCellFrm() && + rLower.IsAccessible( mbIsInPagePreview ) ) + { + sal_Int32 nRow, nCol; + Int32Pair_Impl aCellExtents; + GetRowColumnAndExtent( pLower->Frm(), nRow, nCol, + aCellExtents.first, + aCellExtents.second ); + + maExtents.push_back( aCellExtents ); + } + else + { + // #i77106# + if ( !pLower->IsRowFrm() || + IncludeRow( *pLower ) ) + { + CollectExtents( pLower ); + } + } + } + ++aIter; + } +} + +sal_Bool SwAccessibleTableData_Impl::FindCell( + const Point& rPos, const SwFrm *pFrm, sal_Bool bExact, + const SwFrm *& rRet ) const +{ + sal_Bool bFound = sal_False; + + const SwAccessibleChildSList aList( *pFrm, mrAccMap ); + SwAccessibleChildSList::const_iterator aIter( aList.begin() ); + SwAccessibleChildSList::const_iterator aEndIter( aList.end() ); + while( !bFound && aIter != aEndIter ) + { + const SwAccessibleChild& rLower = *aIter; + const SwFrm *pLower = rLower.GetSwFrm(); + OSL_ENSURE( pLower, "child should be a frame" ); + if( pLower ) + { + if( rLower.IsAccessible( mbIsInPagePreview ) ) + { + OSL_ENSURE( pLower->IsCellFrm(), "lower is not a cell frame" ); + const SwRect& rFrm = pLower->Frm(); + if( rFrm.Right() >= rPos.X() && rFrm.Bottom() >= rPos.Y() ) + { + // We have found the cell + OSL_ENSURE( rFrm.Left() <= rPos.X() && rFrm.Top() <= rPos.Y(), + "find frame moved to far!" ); + bFound = sal_True; + if( !bExact || + (rFrm.Top() == rPos.Y() && rFrm.Left() == rPos.Y() ) ) + { + rRet = pLower; + } + } + } + else + { + // #i77106# + if ( !pLower->IsRowFrm() || + IncludeRow( *pLower ) ) + { + bFound = FindCell( rPos, pLower, bExact, rRet ); + } + } + } + ++aIter; + } + + return bFound; +} + +void SwAccessibleTableData_Impl::GetSelection( + const Point& rTabPos, + const SwRect& rArea, + const SwSelBoxes& rSelBoxes, + const SwFrm *pFrm, + SwAccTableSelHander_Impl& rSelHdl, + sal_Bool bColumns ) const +{ + const SwAccessibleChildSList aList( *pFrm, mrAccMap ); + SwAccessibleChildSList::const_iterator aIter( aList.begin() ); + SwAccessibleChildSList::const_iterator aEndIter( aList.end() ); + while( aIter != aEndIter ) + { + const SwAccessibleChild& rLower = *aIter; + const SwFrm *pLower = rLower.GetSwFrm(); + OSL_ENSURE( pLower, "child should be a frame" ); + const SwRect& rBox = rLower.GetBox( mrAccMap ); + if( pLower && rBox.IsOver( rArea ) ) + { + if( rLower.IsAccessible( mbIsInPagePreview ) ) + { + OSL_ENSURE( pLower->IsCellFrm(), "lower is not a cell frame" ); + const SwCellFrm *pCFrm = + static_cast < const SwCellFrm * >( pLower ); + SwTableBox *pBox = + const_cast< SwTableBox *>( pCFrm->GetTabBox() ); //SVPtrArr! + if( !rSelBoxes.Seek_Entry( pBox ) ) + { + const Int32Set_Impl rRowsOrCols = + bColumns ? maColumns : maRows; + + sal_Int32 nPos = bColumns ? (rBox.Left() - rTabPos.X()) + : (rBox.Top() - rTabPos.Y()); + Int32Set_Impl::const_iterator aSttRowOrCol( + rRowsOrCols.lower_bound( nPos ) ); + sal_Int32 nRowOrCol = + static_cast< sal_Int32 >( ::std::distance( + rRowsOrCols.begin(), aSttRowOrCol ) ); + + nPos = bColumns ? (rBox.Right() - rTabPos.X()) + : (rBox.Bottom() - rTabPos.Y()); + Int32Set_Impl::const_iterator aEndRowOrCol( + rRowsOrCols.upper_bound( nPos ) ); + sal_Int32 nExt = + static_cast< sal_Int32 >( ::std::distance( + aSttRowOrCol, aEndRowOrCol ) ); + + rSelHdl.Unselect( nRowOrCol, nExt ); + } + } + else + { + // #i77106# + if ( !pLower->IsRowFrm() || + IncludeRow( *pLower ) ) + { + GetSelection( rTabPos, rArea, rSelBoxes, pLower, rSelHdl, + bColumns ); + } + } + } + ++aIter; + } +} + +const SwFrm *SwAccessibleTableData_Impl::GetCell( + sal_Int32 nRow, sal_Int32 nColumn, sal_Bool, + SwAccessibleTable *pThis ) const + throw(lang::IndexOutOfBoundsException ) +{ + CheckRowAndCol( nRow, nColumn, pThis ); + + Int32Set_Impl::const_iterator aSttCol( GetColumnIter( nColumn ) ); + Int32Set_Impl::const_iterator aSttRow( GetRowIter( nRow ) ); + const SwFrm *pCellFrm = GetCellAtPos( *aSttCol, *aSttRow, sal_False ); + + return pCellFrm; +} + +void SwAccessibleTableData_Impl::GetSelection( + sal_Int32 nStart, sal_Int32 nEnd, + const SwSelBoxes& rSelBoxes, + SwAccTableSelHander_Impl& rSelHdl, + sal_Bool bColumns ) const +{ + SwRect aArea( mpTabFrm->Frm() ); + Point aPos( aArea.Pos() ); + + const Int32Set_Impl& rRowsOrColumns = bColumns ? maColumns : maRows; + if( nStart > 0 ) + { + Int32Set_Impl::const_iterator aStt( rRowsOrColumns.begin() ); + ::std::advance( aStt, + static_cast< Int32Set_Impl::difference_type >( nStart ) ); + if( bColumns ) + aArea.Left( *aStt + aPos.X() ); + else + aArea.Top( *aStt + aPos.Y() ); + } + if( nEnd < static_cast< sal_Int32 >( rRowsOrColumns.size() ) ) + { + Int32Set_Impl::const_iterator aEnd( rRowsOrColumns.begin() ); + ::std::advance( aEnd, + static_cast< Int32Set_Impl::difference_type >( nEnd ) ); + if( bColumns ) + aArea.Right( *aEnd + aPos.X() - 1 ); + else + aArea.Bottom( *aEnd + aPos.Y() - 1 ); + } + + GetSelection( aPos, aArea, rSelBoxes, mpTabFrm, rSelHdl, bColumns ); +} + +const SwFrm *SwAccessibleTableData_Impl::GetCellAtPos( + sal_Int32 nLeft, sal_Int32 nTop, sal_Bool bExact ) const +{ + Point aPos( mpTabFrm->Frm().Pos() ); + aPos.Move( nLeft, nTop ); + const SwFrm *pRet = 0; + FindCell( aPos, mpTabFrm, bExact, pRet ); + + return pRet; +} + +inline sal_Int32 SwAccessibleTableData_Impl::GetRowCount() const +{ + return static_cast< sal_Int32 >( maRows.size() ); +} + +inline sal_Int32 SwAccessibleTableData_Impl::GetColumnCount() const +{ + return static_cast< sal_Int32 >( maColumns.size() ); +} + +sal_Bool SwAccessibleTableData_Impl::CompareExtents( + const SwAccessibleTableData_Impl& rCmp ) const +{ + if( maExtents.size() != rCmp.maExtents.size() ) + return sal_False; + + Int32PairList_Impl::const_iterator aIter( maExtents.begin() ); + Int32PairList_Impl::const_iterator aEndIter( maExtents.end() ); + Int32PairList_Impl::const_iterator aCmpIter( rCmp.maExtents.begin() ); + while( aIter != aEndIter ) + { + if( *aIter != *aCmpIter ) + return sal_False; + + ++aIter; + ++aCmpIter; + } + + return sal_True; +} + +SwAccessibleTableData_Impl::SwAccessibleTableData_Impl( SwAccessibleMap& rAccMap, + const SwTabFrm *pTabFrm, + sal_Bool bIsInPagePreview, + bool bOnlyTableColumnHeader ) + : mrAccMap( rAccMap ) + , maTabFrmPos( pTabFrm->Frm().Pos() ) + , mpTabFrm( pTabFrm ) + , mbIsInPagePreview( bIsInPagePreview ) + , mbOnlyTableColumnHeader( bOnlyTableColumnHeader ) +{ + CollectData( mpTabFrm ); + CollectExtents( mpTabFrm ); +} + +inline Int32Set_Impl::const_iterator SwAccessibleTableData_Impl::GetRowIter( + sal_Int32 nRow ) const +{ + Int32Set_Impl::const_iterator aCol( GetRows().begin() ); + if( nRow > 0 ) + { + ::std::advance( aCol, + static_cast< Int32Set_Impl::difference_type >( nRow ) ); + } + return aCol; +} + +inline Int32Set_Impl::const_iterator SwAccessibleTableData_Impl::GetColumnIter( + sal_Int32 nColumn ) const +{ + Int32Set_Impl::const_iterator aCol = GetColumns().begin(); + if( nColumn > 0 ) + { + ::std::advance( aCol, + static_cast< Int32Set_Impl::difference_type >( nColumn ) ); + } + return aCol; +} + +void SwAccessibleTableData_Impl::CheckRowAndCol( + sal_Int32 nRow, sal_Int32 nCol, SwAccessibleTable *pThis ) const + throw(lang::IndexOutOfBoundsException ) +{ + if( ( nRow < 0 || nRow >= static_cast< sal_Int32 >( maRows.size() ) ) || + ( nCol < 0 || nCol >= static_cast< sal_Int32 >( maColumns.size() ) ) ) + { + uno::Reference < XAccessibleTable > xThis( pThis ); + lang::IndexOutOfBoundsException aExcept( + OUString( RTL_CONSTASCII_USTRINGPARAM( + "row or column index out of range") ), + xThis ); + throw aExcept; + } +} + +void SwAccessibleTableData_Impl::GetRowColumnAndExtent( + const SwRect& rBox, + sal_Int32& rRow, sal_Int32& rColumn, + sal_Int32& rRowExtent, sal_Int32& rColumnExtent ) const +{ + Int32Set_Impl::const_iterator aStt( + maRows.lower_bound( rBox.Top() - maTabFrmPos.Y() ) ); + Int32Set_Impl::const_iterator aEnd( + maRows.upper_bound( rBox.Bottom() - maTabFrmPos.Y() ) ); + rRow = + static_cast< sal_Int32 >( ::std::distance( maRows.begin(), aStt ) ); + rRowExtent = + static_cast< sal_Int32 >( ::std::distance( aStt, aEnd ) ); + + aStt = maColumns.lower_bound( rBox.Left() - maTabFrmPos.X() ); + aEnd = maColumns.upper_bound( rBox.Right() - maTabFrmPos.X() ); + rColumn = + static_cast< sal_Int32 >( ::std::distance( maColumns.begin(), aStt ) ); + rColumnExtent = + static_cast< sal_Int32 >( ::std::distance( aStt, aEnd ) ); +} + +//------------------------------------------------------------------------------ + +class SwAccSingleTableSelHander_Impl : public SwAccTableSelHander_Impl +{ + sal_Bool bSelected; + +public: + + inline SwAccSingleTableSelHander_Impl(); + + inline sal_Bool IsSelected() const { return bSelected; } + + virtual void Unselect( sal_Int32, sal_Int32 ); +}; + +inline SwAccSingleTableSelHander_Impl::SwAccSingleTableSelHander_Impl() : + bSelected( sal_True ) +{ +} + +void SwAccSingleTableSelHander_Impl::Unselect( sal_Int32, sal_Int32 ) +{ + bSelected = sal_False; +} + +//------------------------------------------------------------------------------ + +class SwAccAllTableSelHander_Impl : public SwAccTableSelHander_Impl + +{ + ::std::vector< sal_Bool > aSelected; + sal_Int32 nCount; + +public: + + inline SwAccAllTableSelHander_Impl( sal_Int32 nSize ); + + uno::Sequence < sal_Int32 > GetSelSequence(); + + virtual void Unselect( sal_Int32 nRowOrCol, sal_Int32 nExt ); + virtual ~SwAccAllTableSelHander_Impl(); +}; + +SwAccAllTableSelHander_Impl::~SwAccAllTableSelHander_Impl() +{ +} + +inline SwAccAllTableSelHander_Impl::SwAccAllTableSelHander_Impl( sal_Int32 nSize ) : + aSelected( nSize, sal_True ), + nCount( nSize ) +{ +} + +uno::Sequence < sal_Int32 > SwAccAllTableSelHander_Impl::GetSelSequence() +{ + OSL_ENSURE( nCount >= 0, "underflow" ); + uno::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++; + } + } + + OSL_ENSURE( nPos == nCount, "count is wrong" ); + + return aRet; +} + +void SwAccAllTableSelHander_Impl::Unselect( sal_Int32 nRowOrCol, + sal_Int32 nExt ) +{ + OSL_ENSURE( static_cast< size_t >( nRowOrCol ) < aSelected.size(), + "index to large" ); + OSL_ENSURE( static_cast< size_t >( nRowOrCol+nExt ) <= aSelected.size(), + "extent to large" ); + while( nExt ) + { + if( aSelected[static_cast< size_t >( nRowOrCol )] ) + { + aSelected[static_cast< size_t >( nRowOrCol )] = sal_False; + nCount--; + } + nExt--; + nRowOrCol++; + } +} + +//------------------------------------------------------------------------------ + +const SwSelBoxes *SwAccessibleTable::GetSelBoxes() const +{ + const SwSelBoxes *pSelBoxes = 0; + const SwCrsrShell *pCSh = GetCrsrShell(); + if( (pCSh != NULL) && pCSh->IsTableMode() ) + { + pSelBoxes = &pCSh->GetTableCrsr()->GetBoxes(); + } + + return pSelBoxes; +} + +void SwAccessibleTable::FireTableChangeEvent( + const SwAccessibleTableData_Impl& rTableData ) +{ + AccessibleTableModelChange aModelChange; + aModelChange.Type = AccessibleTableModelChangeType::UPDATE; + aModelChange.FirstRow = 0; + aModelChange.LastRow = rTableData.GetRowCount() - 1; + aModelChange.FirstColumn = 0; + aModelChange.LastColumn = rTableData.GetColumnCount() - 1; + + AccessibleEventObject aEvent; + aEvent.EventId = AccessibleEventId::TABLE_MODEL_CHANGED; + aEvent.NewValue <<= aModelChange; + + FireAccessibleEvent( aEvent ); +} + + +const SwTableBox* SwAccessibleTable::GetTableBox( sal_Int32 nChildIndex ) const +{ + DBG_ASSERT( nChildIndex >= 0, "Illegal child index." ); + DBG_ASSERT( nChildIndex < const_cast<SwAccessibleTable*>(this)->getAccessibleChildCount(), "Illegal child index." ); // #i77106# + + const SwTableBox* pBox = NULL; + + // get table box for 'our' table cell + SwAccessibleChild aCell( GetChild( *(const_cast<SwAccessibleMap*>(GetMap())), nChildIndex ) ); + if( aCell.GetSwFrm() ) + { + const SwFrm* pChildFrm = aCell.GetSwFrm(); + if( (pChildFrm != NULL) && pChildFrm->IsCellFrm() ) + { + const SwCellFrm* pCellFrm = + static_cast<const SwCellFrm*>( pChildFrm ); + pBox = pCellFrm->GetTabBox(); + } + } + + DBG_ASSERT( pBox != NULL, "We need the table box." ); + return pBox; +} + +sal_Bool SwAccessibleTable::IsChildSelected( sal_Int32 nChildIndex ) const +{ + sal_Bool bRet = sal_False; + const SwSelBoxes* pSelBoxes = GetSelBoxes(); + if( pSelBoxes ) + { + const SwTableBox* pBox = GetTableBox( nChildIndex ); + DBG_ASSERT( pBox != NULL, "We need the table box." ); + bRet = pSelBoxes->Seek_Entry( const_cast<SwTableBox*>( pBox ) ); + } + + return bRet; +} + +sal_Int32 SwAccessibleTable::GetIndexOfSelectedChild( + sal_Int32 nSelectedChildIndex ) const +{ + // iterate over all children to n-th isAccessibleChildSelected() + sal_Int32 nChildren = const_cast<SwAccessibleTable*>(this)->getAccessibleChildCount(); // #i77106# + if( nSelectedChildIndex >= nChildren ) + return -1L; + + sal_Int32 n = 0; + while( n < nChildren ) + { + if( IsChildSelected( n ) ) + { + if( 0 == nSelectedChildIndex ) + break; + else + --nSelectedChildIndex; + } + ++n; + } + + return n < nChildren ? n : -1L; +} + +void SwAccessibleTable::GetStates( + ::utl::AccessibleStateSetHelper& rStateSet ) +{ + SwAccessibleContext::GetStates( rStateSet ); + + // MULTISELECTABLE + SwCrsrShell* pCrsrShell = GetCrsrShell(); + if( pCrsrShell ) + rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE ); +} + +SwAccessibleTable::SwAccessibleTable( + SwAccessibleMap* pInitMap, + const SwTabFrm* pTabFrm ) : + SwAccessibleContext( pInitMap, AccessibleRole::TABLE, pTabFrm ), + mpTableData( 0 ) +{ + SolarMutexGuard aGuard; + + const SwFrmFmt *pFrmFmt = pTabFrm->GetFmt(); + const_cast< SwFrmFmt * >( pFrmFmt )->Add( this ); + const String& rName = pFrmFmt->GetName(); + + OUStringBuffer aBuffer( rName.Len() + 4 ); + aBuffer.append( OUString(rName) ); + aBuffer.append( static_cast<sal_Unicode>( '-' ) ); + aBuffer.append( static_cast<sal_Int32>( pTabFrm->GetPhyPageNum() ) ); + + SetName( aBuffer.makeStringAndClear() ); + + OUString sArg1( static_cast< const SwTabFrm * >( GetFrm() ) + ->GetFmt()->GetName() ); + OUString sArg2( GetFormattedPageNumber() ); + + sDesc = GetResource( STR_ACCESS_TABLE_DESC, &sArg1, &sArg2 ); +} + +SwAccessibleTable::~SwAccessibleTable() +{ + SolarMutexGuard aGuard; + + delete mpTableData; +} + +void SwAccessibleTable::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew) +{ + sal_uInt16 nWhich = pOld ? pOld->Which() : pNew ? pNew->Which() : 0 ; + const SwTabFrm *pTabFrm = static_cast< const SwTabFrm * >( GetFrm() ); + switch( nWhich ) + { + case RES_NAME_CHANGED: + if( pTabFrm ) + { + const SwFrmFmt *pFrmFmt = pTabFrm->GetFmt(); + OSL_ENSURE( pFrmFmt == GetRegisteredIn(), "invalid frame" ); + + OUString sOldName( GetName() ); + + const String& rNewTabName = pFrmFmt->GetName(); + OUStringBuffer aBuffer( rNewTabName.Len() + 4 ); + aBuffer.append( OUString(rNewTabName) ); + aBuffer.append( static_cast<sal_Unicode>( '-' ) ); + aBuffer.append( static_cast<sal_Int32>( pTabFrm->GetPhyPageNum() ) ); + + SetName( aBuffer.makeStringAndClear() ); + if( sOldName != GetName() ) + { + AccessibleEventObject aEvent; + aEvent.EventId = AccessibleEventId::NAME_CHANGED; + aEvent.OldValue <<= sOldName; + aEvent.NewValue <<= GetName(); + FireAccessibleEvent( aEvent ); + } + + OUString sOldDesc( sDesc ); + OUString sArg1( rNewTabName ); + OUString sArg2( GetFormattedPageNumber() ); + + sDesc = GetResource( STR_ACCESS_TABLE_DESC, &sArg1, &sArg2 ); + if( sDesc != sOldDesc ) + { + AccessibleEventObject aEvent; + aEvent.EventId = AccessibleEventId::DESCRIPTION_CHANGED; + aEvent.OldValue <<= sOldDesc; + aEvent.NewValue <<= sDesc; + FireAccessibleEvent( aEvent ); + } + } + break; + + case RES_OBJECTDYING: + // mba: it seems that this class intentionally does not call code in base class SwClient + if( GetRegisteredIn() == + static_cast< SwModify *>( static_cast< const SwPtrMsgPoolItem * >( pOld )->pObject ) ) + GetRegisteredInNonConst()->Remove( this ); + break; + + default: + // mba: former call to base class method removed as it is meant to handle only RES_OBJECTDYING + break; + } +} + +uno::Any SwAccessibleTable::queryInterface( const uno::Type& rType ) + throw (uno::RuntimeException) +{ + uno::Any aRet; + if ( rType == ::getCppuType( static_cast< uno::Reference< XAccessibleTable > * >( 0 ) ) ) + { + uno::Reference<XAccessibleTable> xThis( this ); + aRet <<= xThis; + } + else if ( rType == ::getCppuType( static_cast< uno::Reference< XAccessibleSelection > * >( 0 ) ) ) + { + uno::Reference<XAccessibleSelection> xSelection( this ); + aRet <<= xSelection; + } + else + { + aRet = SwAccessibleContext::queryInterface(rType); + } + + return aRet; +} + +//====== XTypeProvider ==================================================== +uno::Sequence< uno::Type > SAL_CALL SwAccessibleTable::getTypes() + throw(uno::RuntimeException) +{ + uno::Sequence< uno::Type > aTypes( SwAccessibleContext::getTypes() ); + + sal_Int32 nIndex = aTypes.getLength(); + aTypes.realloc( nIndex + 2 ); + + uno::Type* pTypes = aTypes.getArray(); + pTypes[nIndex++] = ::getCppuType( static_cast< uno::Reference< XAccessibleSelection > * >( 0 ) ); + pTypes[nIndex++] = ::getCppuType( static_cast< uno::Reference< XAccessibleTable > * >( 0 ) ); + + return aTypes; +} + +uno::Sequence< sal_Int8 > SAL_CALL SwAccessibleTable::getImplementationId() + throw(uno::RuntimeException) +{ + SolarMutexGuard aGuard; + static uno::Sequence< sal_Int8 > aId( 16 ); + static sal_Bool bInit = sal_False; + if(!bInit) + { + rtl_createUuid( (sal_uInt8 *)(aId.getArray() ), 0, sal_True ); + bInit = sal_True; + } + return aId; +} + +// #i77106# +SwAccessibleTableData_Impl* SwAccessibleTable::CreateNewTableData() +{ + const SwTabFrm* pTabFrm = static_cast<const SwTabFrm*>( GetFrm() ); + return new SwAccessibleTableData_Impl( *GetMap(), pTabFrm, IsInPagePreview() ); +} +// <-- + +void SwAccessibleTable::UpdateTableData() +{ + // #i77106# - usage of new method <CreateNewTableData()> + delete mpTableData; + mpTableData = CreateNewTableData(); + // <-- +} + +void SwAccessibleTable::ClearTableData() +{ + delete mpTableData; + mpTableData = 0; +} + +OUString SAL_CALL SwAccessibleTable::getAccessibleDescription (void) + throw (uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleContext ) + + return sDesc; +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleRowCount() + throw (uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + return GetTableData().GetRowCount(); +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleColumnCount( ) + throw (uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + return GetTableData().GetColumnCount(); +} + +OUString SAL_CALL SwAccessibleTable::getAccessibleRowDescription( + sal_Int32 nRow ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + // #i87532# - determine table cell in <nRow>th row and + // in first column of row header table and return its text content. + OUString sRowDesc; + + GetTableData().CheckRowAndCol(nRow, 0, this); + + uno::Reference< XAccessibleTable > xTableRowHeader = getAccessibleRowHeaders(); + if ( xTableRowHeader.is() ) + { + uno::Reference< XAccessible > xRowHeaderCell = + xTableRowHeader->getAccessibleCellAt( nRow, 0 ); + OSL_ENSURE( xRowHeaderCell.is(), + "<SwAccessibleTable::getAccessibleRowDescription(..)> - missing row header cell -> serious issue." ); + uno::Reference< XAccessibleContext > xRowHeaderCellContext = + xRowHeaderCell->getAccessibleContext(); + const sal_Int32 nCellChildCount( xRowHeaderCellContext->getAccessibleChildCount() ); + for ( sal_Int32 nChildIndex = 0; nChildIndex < nCellChildCount; ++nChildIndex ) + { + uno::Reference< XAccessible > xChild = xRowHeaderCellContext->getAccessibleChild( nChildIndex ); + uno::Reference< XAccessibleText > xChildText( xChild, uno::UNO_QUERY ); + if ( xChildText.is() ) + { + sRowDesc = sRowDesc + xChildText->getText(); + } + } + } + + return sRowDesc; + // <-- +} + +OUString SAL_CALL SwAccessibleTable::getAccessibleColumnDescription( + sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + // #i87532# - determine table cell in first row and + // in <nColumn>th column of column header table and return its text content. + OUString sColumnDesc; + + GetTableData().CheckRowAndCol(0, nColumn, this); + + uno::Reference< XAccessibleTable > xTableColumnHeader = getAccessibleColumnHeaders(); + if ( xTableColumnHeader.is() ) + { + uno::Reference< XAccessible > xColumnHeaderCell = + xTableColumnHeader->getAccessibleCellAt( 0, nColumn ); + OSL_ENSURE( xColumnHeaderCell.is(), + "<SwAccessibleTable::getAccessibleColumnDescription(..)> - missing column header cell -> serious issue." ); + uno::Reference< XAccessibleContext > xColumnHeaderCellContext = + xColumnHeaderCell->getAccessibleContext(); + const sal_Int32 nCellChildCount( xColumnHeaderCellContext->getAccessibleChildCount() ); + for ( sal_Int32 nChildIndex = 0; nChildIndex < nCellChildCount; ++nChildIndex ) + { + uno::Reference< XAccessible > xChild = xColumnHeaderCellContext->getAccessibleChild( nChildIndex ); + uno::Reference< XAccessibleText > xChildText( xChild, uno::UNO_QUERY ); + if ( xChildText.is() ) + { + sColumnDesc = sColumnDesc + xChildText->getText(); + } + } + } + + return sColumnDesc; + // <-- +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleRowExtentAt( + sal_Int32 nRow, sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + sal_Int32 nExtend = -1; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + GetTableData().CheckRowAndCol( nRow, nColumn, this ); + + Int32Set_Impl::const_iterator aSttCol( + GetTableData().GetColumnIter( nColumn ) ); + Int32Set_Impl::const_iterator aSttRow( + GetTableData().GetRowIter( nRow ) ); + const SwFrm *pCellFrm = GetTableData().GetCellAtPos( *aSttCol, *aSttRow, + sal_False ); + if( pCellFrm ) + { + sal_Int32 nBottom = pCellFrm->Frm().Bottom(); + nBottom -= GetFrm()->Frm().Top(); + Int32Set_Impl::const_iterator aEndRow( + GetTableData().GetRows().upper_bound( nBottom ) ); + nExtend = + static_cast< sal_Int32 >( ::std::distance( aSttRow, aEndRow ) ); + } + + return nExtend; +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleColumnExtentAt( + sal_Int32 nRow, sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + sal_Int32 nExtend = -1; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + GetTableData().CheckRowAndCol( nRow, nColumn, this ); + + Int32Set_Impl::const_iterator aSttCol( + GetTableData().GetColumnIter( nColumn ) ); + Int32Set_Impl::const_iterator aSttRow( + GetTableData().GetRowIter( nRow ) ); + const SwFrm *pCellFrm = GetTableData().GetCellAtPos( *aSttCol, *aSttRow, + sal_False ); + if( pCellFrm ) + { + sal_Int32 nRight = pCellFrm->Frm().Right(); + nRight -= GetFrm()->Frm().Left(); + Int32Set_Impl::const_iterator aEndCol( + GetTableData().GetColumns().upper_bound( nRight ) ); + nExtend = + static_cast< sal_Int32 >( ::std::distance( aSttCol, aEndCol ) ); + } + + return nExtend; +} + +uno::Reference< XAccessibleTable > SAL_CALL + SwAccessibleTable::getAccessibleRowHeaders( ) + throw (uno::RuntimeException) +{ + // Row headers aren't supported + return uno::Reference< XAccessibleTable >(); +} + +uno::Reference< XAccessibleTable > SAL_CALL + SwAccessibleTable::getAccessibleColumnHeaders( ) + throw (uno::RuntimeException) +{ + // #i87532# - assure that return accesible object is empty, + // if no column header exists. + SwAccessibleTableColHeaders* pTableColHeaders = + new SwAccessibleTableColHeaders( GetMap(), static_cast< const SwTabFrm *>( GetFrm() ) ); + uno::Reference< XAccessibleTable > xTableColumnHeaders( pTableColHeaders ); + if ( pTableColHeaders->getAccessibleChildCount() <= 0 ) + { + return uno::Reference< XAccessibleTable >(); + } + + return xTableColumnHeaders; + // <-- +} + +uno::Sequence< sal_Int32 > SAL_CALL SwAccessibleTable::getSelectedAccessibleRows() + throw (uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + const SwSelBoxes *pSelBoxes = GetSelBoxes(); + if( pSelBoxes ) + { + sal_Int32 nRows = GetTableData().GetRowCount(); + SwAccAllTableSelHander_Impl aSelRows( nRows ); + + GetTableData().GetSelection( 0, nRows, *pSelBoxes, aSelRows, + sal_False ); + + return aSelRows.GetSelSequence(); + } + else + { + return uno::Sequence< sal_Int32 >( 0 ); + } +} + +uno::Sequence< sal_Int32 > SAL_CALL SwAccessibleTable::getSelectedAccessibleColumns() + throw (uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + const SwSelBoxes *pSelBoxes = GetSelBoxes(); + if( pSelBoxes ) + { + sal_Int32 nCols = GetTableData().GetColumnCount(); + SwAccAllTableSelHander_Impl aSelCols( nCols ); + + GetTableData().GetSelection( 0, nCols, *pSelBoxes, aSelCols, sal_True ); + + return aSelCols.GetSelSequence(); + } + else + { + return uno::Sequence< sal_Int32 >( 0 ); + } +} + +sal_Bool SAL_CALL SwAccessibleTable::isAccessibleRowSelected( sal_Int32 nRow ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + GetTableData().CheckRowAndCol( nRow, 0, this ); + + sal_Bool bRet; + const SwSelBoxes *pSelBoxes = GetSelBoxes(); + if( pSelBoxes ) + { + SwAccSingleTableSelHander_Impl aSelRow; + GetTableData().GetSelection( nRow, nRow+1, *pSelBoxes, aSelRow, + sal_False ); + bRet = aSelRow.IsSelected(); + } + else + { + bRet = sal_False; + } + + return bRet; +} + +sal_Bool SAL_CALL SwAccessibleTable::isAccessibleColumnSelected( + sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + GetTableData().CheckRowAndCol( 0, nColumn, this ); + + sal_Bool bRet; + const SwSelBoxes *pSelBoxes = GetSelBoxes(); + if( pSelBoxes ) + { + SwAccSingleTableSelHander_Impl aSelCol; + + GetTableData().GetSelection( nColumn, nColumn+1, *pSelBoxes, aSelCol, + sal_True ); + bRet = aSelCol.IsSelected(); + } + else + { + bRet = sal_False; + } + + return bRet; +} + +uno::Reference< XAccessible > SAL_CALL SwAccessibleTable::getAccessibleCellAt( + sal_Int32 nRow, sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + uno::Reference< XAccessible > xRet; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + const SwFrm *pCellFrm = + GetTableData().GetCell( nRow, nColumn, sal_False, this ); + if( pCellFrm ) + xRet = GetMap()->GetContext( pCellFrm, sal_True ); + + return xRet; +} + +uno::Reference< XAccessible > SAL_CALL SwAccessibleTable::getAccessibleCaption() + throw (uno::RuntimeException) +{ + // captions aren't supported + return uno::Reference< XAccessible >(); +} + +uno::Reference< XAccessible > SAL_CALL SwAccessibleTable::getAccessibleSummary() + throw (uno::RuntimeException) +{ + // summaries aren't supported + return uno::Reference< XAccessible >(); +} + +sal_Bool SAL_CALL SwAccessibleTable::isAccessibleSelected( + sal_Int32 nRow, sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + sal_Bool bRet = sal_False; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + const SwFrm *pFrm = + GetTableData().GetCell( nRow, nColumn, sal_False, this ); + if( pFrm && pFrm->IsCellFrm() ) + { + const SwSelBoxes *pSelBoxes = GetSelBoxes(); + if( pSelBoxes ) + { + const SwCellFrm *pCFrm = static_cast < const SwCellFrm * >( pFrm ); + SwTableBox *pBox = + const_cast< SwTableBox *>( pCFrm->GetTabBox() ); //SVPtrArr! + bRet = pSelBoxes->Seek_Entry( pBox ); + } + } + + return bRet; +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleIndex( + sal_Int32 nRow, sal_Int32 nColumn ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + sal_Int32 nRet = -1; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + SwAccessibleChild aCell( GetTableData().GetCell( nRow, nColumn, sal_False, this )); + if ( aCell.IsValid() ) + { + nRet = GetChildIndex( *(GetMap()), aCell ); + } + + return nRet; +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleRow( sal_Int32 nChildIndex ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + sal_Int32 nRet = -1; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + // #i77106# + if ( ( nChildIndex < 0 ) || + ( nChildIndex >= getAccessibleChildCount() ) ) + { + throw lang::IndexOutOfBoundsException(); + } + // <-- + + SwAccessibleChild aCell( GetChild( *(GetMap()), nChildIndex ) ); + if ( aCell.GetSwFrm() ) + { + sal_Int32 nTop = aCell.GetSwFrm()->Frm().Top(); + nTop -= GetFrm()->Frm().Top(); + Int32Set_Impl::const_iterator aRow( + GetTableData().GetRows().lower_bound( nTop ) ); + nRet = static_cast< sal_Int32 >( ::std::distance( + GetTableData().GetRows().begin(), aRow ) ); + } + else + { + OSL_ENSURE( !aCell.IsValid(), "SwAccessibleTable::getAccessibleColumn:" + "aCell not expected to be valid."); + + throw lang::IndexOutOfBoundsException(); + } + + return nRet; +} + +sal_Int32 SAL_CALL SwAccessibleTable::getAccessibleColumn( + sal_Int32 nChildIndex ) + throw (lang::IndexOutOfBoundsException, uno::RuntimeException) +{ + sal_Int32 nRet = -1; + + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ) + + // #i77106# + if ( ( nChildIndex < 0 ) || + ( nChildIndex >= getAccessibleChildCount() ) ) + { + throw lang::IndexOutOfBoundsException(); + } + // <-- + + SwAccessibleChild aCell( GetChild( *(GetMap()), nChildIndex ) ); + if ( aCell.GetSwFrm() ) + { + sal_Int32 nLeft = aCell.GetSwFrm()->Frm().Left(); + nLeft -= GetFrm()->Frm().Left(); + Int32Set_Impl::const_iterator aCol( + GetTableData().GetColumns().lower_bound( nLeft ) ); + nRet = static_cast< sal_Int32 >( ::std::distance( + GetTableData().GetColumns().begin(), aCol ) ); + } + else + { + OSL_ENSURE( !aCell.IsValid(), "SwAccessibleTable::getAccessibleColumn:" + "aCell not expected to be valid."); + + throw lang::IndexOutOfBoundsException(); + } + + return nRet; +} + + +OUString SAL_CALL SwAccessibleTable::getImplementationName() + throw( uno::RuntimeException ) +{ + return OUString(RTL_CONSTASCII_USTRINGPARAM(sImplementationName)); +} + +sal_Bool SAL_CALL SwAccessibleTable::supportsService( + const OUString& sTestServiceName) + throw (uno::RuntimeException) +{ + return sTestServiceName.equalsAsciiL( sServiceName, + sizeof(sServiceName)-1 ) || + sTestServiceName.equalsAsciiL( sAccessibleServiceName, + sizeof(sAccessibleServiceName)-1 ); +} + +uno::Sequence< OUString > SAL_CALL SwAccessibleTable::getSupportedServiceNames() + throw( uno::RuntimeException ) +{ + uno::Sequence< OUString > aRet(2); + OUString* pArray = aRet.getArray(); + pArray[0] = OUString( RTL_CONSTASCII_USTRINGPARAM(sServiceName) ); + pArray[1] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleServiceName) ); + return aRet; +} + +void SwAccessibleTable::InvalidatePosOrSize( const SwRect& rOldBox ) +{ + SolarMutexGuard aGuard; + + if( HasTableData() ) + GetTableData().SetTablePos( GetFrm()->Frm().Pos() ); + + SwAccessibleContext::InvalidatePosOrSize( rOldBox ); +} + +void SwAccessibleTable::Dispose( sal_Bool bRecursive ) +{ + SolarMutexGuard aGuard; + + if( GetRegisteredIn() ) + GetRegisteredInNonConst()->Remove( this ); + + SwAccessibleContext::Dispose( bRecursive ); +} + +void SwAccessibleTable::DisposeChild( const SwAccessibleChild& rChildFrmOrObj, + sal_Bool bRecursive ) +{ + SolarMutexGuard aGuard; + + const SwFrm *pFrm = rChildFrmOrObj.GetSwFrm(); + OSL_ENSURE( pFrm, "frame expected" ); + if( HasTableData() ) + { + FireTableChangeEvent( GetTableData() ); + ClearTableData(); + } + + // There are two reason why this method has been called. The first one + // is there is no context for pFrm. The method is them called by + // the map, and we have to call our superclass. + // The other situation is that we have been call by a call to get notified + // about its change. We then must not call the superclass + uno::Reference< XAccessible > xAcc( GetMap()->GetContext( pFrm, sal_False ) ); + if( !xAcc.is() ) + SwAccessibleContext::DisposeChild( rChildFrmOrObj, bRecursive ); +} + +void SwAccessibleTable::InvalidateChildPosOrSize( const SwAccessibleChild& rChildFrmOrObj, + const SwRect& rOldBox ) +{ + SolarMutexGuard aGuard; + + if( HasTableData() ) + { + OSL_ENSURE( !HasTableData() || + GetFrm()->Frm().Pos() == GetTableData().GetTablePos(), + "table has invalid position" ); + if( HasTableData() ) + { + SwAccessibleTableData_Impl *pNewTableData = CreateNewTableData(); // #i77106# + if( !pNewTableData->CompareExtents( GetTableData() ) ) + { + FireTableChangeEvent( GetTableData() ); + ClearTableData(); + mpTableData = pNewTableData; + } + else + { + delete pNewTableData; + } + } + } + + // #i013961# - always call super class method + SwAccessibleContext::InvalidateChildPosOrSize( rChildFrmOrObj, rOldBox ); +} + + +// +// XAccessibleSelection +// + +void SAL_CALL SwAccessibleTable::selectAccessibleChild( + sal_Int32 nChildIndex ) + throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) +{ + SolarMutexGuard aGuard; + CHECK_FOR_DEFUNC( XAccessibleTable ); + + if( (nChildIndex < 0) || (nChildIndex >= getAccessibleChildCount()) ) // #i77106# + throw lang::IndexOutOfBoundsException(); + + // preliminaries: get 'our' table box, and get the cursor shell + const SwTableBox* pBox = GetTableBox( nChildIndex ); + DBG_ASSERT( pBox != NULL, "We need the table box." ); + + SwCrsrShell* pCrsrShell = GetCrsrShell(); + if( pCrsrShell == NULL ) + return; + + // assure, that child, indentified by the given index, isn't already selected. + if ( IsChildSelected( nChildIndex ) ) + { + return; + } + + // now we can start to do the work: check whether we already have + // a table selection (in 'our' table). If so, extend the + // selection, else select the current cell. + + // if we have a selection in a table, check if it's in the + // same table that we're trying to select in + const SwTableNode* pSelectedTable = pCrsrShell->IsCrsrInTbl(); + if( pSelectedTable != NULL ) + { + // get top-most table line + const SwTableLine* pUpper = pBox->GetUpper(); + while( pUpper->GetUpper() != NULL ) + pUpper = pUpper->GetUpper()->GetUpper(); + sal_uInt16 nPos = + pSelectedTable->GetTable().GetTabLines().GetPos( pUpper ); + if( nPos == USHRT_MAX ) + pSelectedTable = NULL; + } + + // create the new selection + const SwStartNode* pStartNode = pBox->GetSttNd(); + if( pSelectedTable == NULL || !pCrsrShell->GetTblCrs() ) + { + pCrsrShell->StartAction(); + // Set cursor into current cell. This deletes any table cursor. + SwPaM aPaM( *pStartNode ); + aPaM.Move( fnMoveForward, fnGoNode ); + Select( aPaM ); + // Move cursor to the end of the table creating a selection and a table + // cursor. + pCrsrShell->SetMark(); + pCrsrShell->MoveTable( fnTableCurr, fnTableEnd ); + // now set the cursor into the cell again. + SwPaM *pPaM = pCrsrShell->GetTblCrs() ? pCrsrShell->GetTblCrs() + : pCrsrShell->GetCrsr(); + *pPaM->GetPoint() = *pPaM->GetMark(); + pCrsrShell->EndAction(); + // we now have one cell selected! + } + else + { + // if the cursor is already in this table, + // expand the current selection (i.e., set + // point to new position; keep mark) + SwPaM aPaM( *pStartNode ); + aPaM.Move( fnMoveForward, fnGoNode ); + aPaM.SetMark(); + const SwPaM *pPaM = pCrsrShell->GetTblCrs() ? pCrsrShell->GetTblCrs() + : pCrsrShell->GetCrsr(); + *(aPaM.GetMark()) = *pPaM->GetMark(); + Select( aPaM ); + + } +} + + +sal_Bool SAL_CALL SwAccessibleTable::isAccessibleChildSelected( + sal_Int32 nChildIndex ) + throw ( lang::IndexOutOfBoundsException, + uno::RuntimeException ) +{ + SolarMutexGuard aGuard; + CHECK_FOR_DEFUNC( XAccessibleTable ); + + if( (nChildIndex < 0) || (nChildIndex >= getAccessibleChildCount()) ) // #i77106# + throw lang::IndexOutOfBoundsException(); + + return IsChildSelected( nChildIndex ); +} + +void SAL_CALL SwAccessibleTable::clearAccessibleSelection( ) + throw ( uno::RuntimeException ) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleTable ); + + SwCrsrShell* pCrsrShell = GetCrsrShell(); + if( pCrsrShell != NULL ) + { + pCrsrShell->StartAction(); + pCrsrShell->ClearMark(); + pCrsrShell->EndAction(); + } +} + +void SAL_CALL SwAccessibleTable::selectAllAccessibleChildren( ) + throw ( uno::RuntimeException ) +{ + // first clear selection, then select first and last child + clearAccessibleSelection(); + selectAccessibleChild( 0 ); + selectAccessibleChild( getAccessibleChildCount()-1 ); // #i77106# +} + +sal_Int32 SAL_CALL SwAccessibleTable::getSelectedAccessibleChildCount( ) + throw ( uno::RuntimeException ) +{ + SolarMutexGuard aGuard; + CHECK_FOR_DEFUNC( XAccessibleTable ); + + // iterate over all children and count isAccessibleChildSelected() + sal_Int32 nCount = 0; + + sal_Int32 nChildren = getAccessibleChildCount(); // #i71106# + for( sal_Int32 n = 0; n < nChildren; n++ ) + if( IsChildSelected( n ) ) + nCount++; + + return nCount; +} + +uno::Reference<XAccessible> SAL_CALL SwAccessibleTable::getSelectedAccessibleChild( + sal_Int32 nSelectedChildIndex ) + throw ( lang::IndexOutOfBoundsException, + uno::RuntimeException) +{ + SolarMutexGuard aGuard; + CHECK_FOR_DEFUNC( XAccessibleTable ); + + // paremter checking (part 1): index lower 0 + if( nSelectedChildIndex < 0 ) + throw lang::IndexOutOfBoundsException(); + + sal_Int32 nChildIndex = GetIndexOfSelectedChild( nSelectedChildIndex ); + + // parameter checking (part 2): index higher than selected children? + if( nChildIndex < 0 ) + throw lang::IndexOutOfBoundsException(); + + // #i77106# + if ( nChildIndex >= getAccessibleChildCount() ) + { + throw lang::IndexOutOfBoundsException(); + } + + return getAccessibleChild( nChildIndex ); +} + +// index has to be treated as global child index. +void SAL_CALL SwAccessibleTable::deselectAccessibleChild( + sal_Int32 nChildIndex ) + throw ( lang::IndexOutOfBoundsException, + uno::RuntimeException ) +{ + SolarMutexGuard aGuard; + CHECK_FOR_DEFUNC( XAccessibleTable ); + + SwCrsrShell* pCrsrShell = GetCrsrShell(); + + // index has to be treated as global child index + if ( !pCrsrShell ) + throw lang::IndexOutOfBoundsException(); + + // assure, that given child index is in bounds. + if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() ) // #i77106# + throw lang::IndexOutOfBoundsException(); + + // assure, that child, identified by the given index, is selected. + if ( !IsChildSelected( nChildIndex ) ) + return; + // <-- + + const SwTableBox* pBox = GetTableBox( nChildIndex ); + DBG_ASSERT( pBox != NULL, "We need the table box." ); + + // If we unselect point, then set cursor to mark. If we clear another + // selected box, then set cursor to point. + // reduce selection to mark. + SwPaM *pPaM = pCrsrShell->GetTblCrs() ? pCrsrShell->GetTblCrs() + : pCrsrShell->GetCrsr(); + sal_Bool bDeselectPoint = + pBox->GetSttNd() == + pPaM->GetPoint()->nNode.GetNode().FindTableBoxStartNode(); + + SwPaM aPaM( bDeselectPoint ? *pPaM->GetMark() : *pPaM->GetPoint() ); + + pCrsrShell->StartAction(); + + // Set cursor into either point or mark + Select( aPaM ); + // Move cursor to the end of the table creating a selection and a table + // cursor. + pCrsrShell->SetMark(); + pCrsrShell->MoveTable( fnTableCurr, fnTableEnd ); + // now set the cursor into the cell again. + pPaM = pCrsrShell->GetTblCrs() ? pCrsrShell->GetTblCrs() + : pCrsrShell->GetCrsr(); + *pPaM->GetPoint() = *pPaM->GetMark(); + pCrsrShell->EndAction(); +} + +// #i77106# - implementation of class <SwAccessibleTableColHeaders> +SwAccessibleTableColHeaders::SwAccessibleTableColHeaders( SwAccessibleMap *pMap2, + const SwTabFrm *pTabFrm ) + : SwAccessibleTable( pMap2, pTabFrm ) +{ + SolarMutexGuard aGuard; + + const SwFrmFmt *pFrmFmt = pTabFrm->GetFmt(); + const_cast< SwFrmFmt * >( pFrmFmt )->Add( this ); + const String& rName = pFrmFmt->GetName(); + + OUStringBuffer aBuffer( rName.Len() + 15 + 6 ); + aBuffer.append( OUString(rName) ); + aBuffer.append( String::CreateFromAscii("-ColumnHeaders-") ); + aBuffer.append( static_cast<sal_Int32>( pTabFrm->GetPhyPageNum() ) ); + + SetName( aBuffer.makeStringAndClear() ); + + OUStringBuffer aBuffer2( rName.Len() + 14 ); + aBuffer2.append( OUString(rName) ); + aBuffer2.append( String::CreateFromAscii("-ColumnHeaders") ); + OUString sArg1( aBuffer2.makeStringAndClear() ); + OUString sArg2( GetFormattedPageNumber() ); + + OUString sDesc2 = GetResource( STR_ACCESS_TABLE_DESC, &sArg1, &sArg2 ); + SetDesc( sDesc2 ); + + NotRegisteredAtAccessibleMap(); // #i85634# +} + +SwAccessibleTableData_Impl* SwAccessibleTableColHeaders::CreateNewTableData() +{ + const SwTabFrm* pTabFrm = static_cast<const SwTabFrm*>( GetFrm() ); + return new SwAccessibleTableData_Impl( *(GetMap()), pTabFrm, IsInPagePreview(), true ); +} + + +void SwAccessibleTableColHeaders::Modify( const SfxPoolItem * /*pOld*/, const SfxPoolItem * /*pNew*/ ) +{ +} + +//===== XInterface ====================================================== +uno::Any SAL_CALL SwAccessibleTableColHeaders::queryInterface( const uno::Type& aType ) + throw (uno::RuntimeException) +{ + return SwAccessibleTable::queryInterface( aType ); +} + +//===== XAccessibleContext ============================================== +sal_Int32 SAL_CALL SwAccessibleTableColHeaders::getAccessibleChildCount(void) + throw (uno::RuntimeException) +{ + SolarMutexGuard aGuard; + + CHECK_FOR_DEFUNC( XAccessibleContext ) + + sal_Int32 nCount = 0; + + const SwTabFrm* pTabFrm = static_cast<const SwTabFrm*>( GetFrm() ); + const SwAccessibleChildSList aVisList( GetVisArea(), *pTabFrm, *(GetMap()) ); + SwAccessibleChildSList::const_iterator aIter( aVisList.begin() ); + while( aIter != aVisList.end() ) + { + const SwAccessibleChild& rLower = *aIter; + if( rLower.IsAccessible( IsInPagePreview() ) ) + { + nCount++; + } + else if( rLower.GetSwFrm() ) + { + // There are no unaccessible SdrObjects that count + if ( !rLower.GetSwFrm()->IsRowFrm() || + pTabFrm->IsInHeadline( *(rLower.GetSwFrm()) ) ) + { + nCount += SwAccessibleFrame::GetChildCount( *(GetMap()), + GetVisArea(), + rLower.GetSwFrm(), + IsInPagePreview() ); + } + } + ++aIter; + } + + return nCount; +} + +uno::Reference< XAccessible> SAL_CALL + SwAccessibleTableColHeaders::getAccessibleChild (sal_Int32 nIndex) + throw (uno::RuntimeException, lang::IndexOutOfBoundsException) +{ + if ( nIndex < 0 || nIndex >= getAccessibleChildCount() ) + { + throw lang::IndexOutOfBoundsException(); + } + + return SwAccessibleTable::getAccessibleChild( nIndex ); +} + +//===== XAccessibleTable ================================================ +uno::Reference< XAccessibleTable > + SAL_CALL SwAccessibleTableColHeaders::getAccessibleRowHeaders() + throw (uno::RuntimeException) +{ + return uno::Reference< XAccessibleTable >(); +} + +uno::Reference< XAccessibleTable > + SAL_CALL SwAccessibleTableColHeaders::getAccessibleColumnHeaders() + throw (uno::RuntimeException) +{ + return uno::Reference< XAccessibleTable >(); +} + +//===== XServiceInfo ==================================================== + +::rtl::OUString SAL_CALL SwAccessibleTableColHeaders::getImplementationName (void) + throw (uno::RuntimeException) +{ + static const sal_Char sImplName[] = "com.sun.star.comp.Writer.SwAccessibleTableColumnHeadersView"; + return OUString(RTL_CONSTASCII_USTRINGPARAM(sImplName)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |