diff options
Diffstat (limited to 'winaccessibility/source/UAccCOM/AccTable.cpp')
| -rw-r--r-- | winaccessibility/source/UAccCOM/AccTable.cpp | 1069 |
1 files changed, 1069 insertions, 0 deletions
diff --git a/winaccessibility/source/UAccCOM/AccTable.cpp b/winaccessibility/source/UAccCOM/AccTable.cpp new file mode 100644 index 000000000000..4ad5e22c782e --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccTable.cpp @@ -0,0 +1,1069 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +/** + * AccTable.cpp : Implementation of CAccTable. + */ +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccTable.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include "MAccessible.h" + +#include "act.hxx" + +#ifndef _COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLETABLEEXTENT_HPP_ +#include <com/sun/star/accessibility/XAccessibleTableSelection.hpp> +#endif + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; +/** + * Gets accessible table cell. + * + * @param row the row of the specified cell. + * @param column the column of the specified cell. + * @param accessible the accessible object of the cell. + */ + +STDMETHODIMP CAccTable::get_accessibleAt(long row, long column, IUnknown * * accessible) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(accessible == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessible> pRAcc = GetXInterface()->getAccessibleCellAt(row,column); + + if(!pRAcc.is()) + { + *accessible = NULL; + return E_FAIL; + } + + IAccessible* pRet = NULL; + + BOOL isTRUE = CMAccessible::get_IAccessibleFromXAccessible((long)pRAcc.get(),&pRet); + if(isTRUE) + { + *accessible = (IAccessible2 *)pRet; + pRet->AddRef(); + return S_OK; + } + else if(pRAcc.is()) + { + Reference<XAccessible> pxTable(GetXInterface(),UNO_QUERY); + + CMAccessible::g_pAgent->InsertAccObj(pRAcc.get(),pxTable.get()); + isTRUE = CMAccessible::get_IAccessibleFromXAccessible((long)pRAcc.get(),&pRet); + + if(isTRUE) + { + *accessible = (IAccessible2 *)pRet; + pRet->AddRef(); + return S_OK; + } + } + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets accessible table caption. + * + * @param accessible the accessible object of table cpation. + */ +STDMETHODIMP CAccTable::get_caption(IUnknown * *) +{ + + + ENTER_PROTECTED_BLOCK + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets accessible column description (as string). + * + * @param column the column index. + * @param description the description of the specified column. + */ +STDMETHODIMP CAccTable::get_columnDescription(long column, BSTR * description) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(description == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + const ::rtl::OUString& ouStr = GetXInterface()->getAccessibleColumnDescription(column); + // #CHECK# + + SAFE_SYSFREESTRING(*description);//?? + *description = SysAllocString((OLECHAR*)ouStr.getStr()); + if(description==NULL) + return E_FAIL; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets number of columns spanned by table cell. + * + * @param row the row of the specified cell. + * @param column the column of the specified cell. + * @param spanColumns the column span of the specified cell. + */ +STDMETHODIMP CAccTable::get_columnExtentAt(long row, long column, long * nColumnsSpanned) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + XAccessibleTable *pXAccTable = GetXInterface(); + + // Check pointer. + if(nColumnsSpanned == NULL) + return E_INVALIDARG; + + // Get Extent. + if(pXAccTable) + { + long lExt = pXAccTable->getAccessibleColumnExtentAt(row,column); + + // Fill Extent struct. + *nColumnsSpanned = lExt; + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets accessible column header. + * + * @param column the column index. + * @param accessible the accessible object of the specified column. + */ +STDMETHODIMP CAccTable::get_columnHeader(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingRowIndex) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(accessibleTable == NULL || startingRowIndex == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleTable> pRColumnHeaderTable = GetXInterface()->getAccessibleColumnHeaders(); + if(!pRColumnHeaderTable.is()) + { + *accessibleTable = NULL; + return E_FAIL; + } + + Reference<XAccessible> pRXColumnHeader(pRColumnHeaderTable,UNO_QUERY); + + if(!pRXColumnHeader.is()) + { + *accessibleTable = NULL; + return E_FAIL; + } + *startingRowIndex = 0 ; + + IAccessible* m_pIMacc = NULL; + ActivateActContext(); + HRESULT hr = CoCreateInstance( CLSID_MAccessible, NULL, CLSCTX_ALL , + IID_IMAccessible, + (void **)&m_pIMacc + ); + DeactivateActContext(); + ((CMAccessible*)m_pIMacc)->SetXAccessible((long)pRXColumnHeader.get()); + m_pIMacc->QueryInterface(IID_IAccessibleTable,(void **)accessibleTable); + if( SUCCEEDED(hr) ) + { + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets total number of columns in table. + * + * @param columnCount the number of columns in table. + */ +STDMETHODIMP CAccTable::get_nColumns(long * columnCount) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(columnCount == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *columnCount = GetXInterface()->getAccessibleColumnCount(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets total number of rows in table. + * + * @param rowCount the number of rows in table. + */ +STDMETHODIMP CAccTable::get_nRows(long * rowCount) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(rowCount == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *rowCount = GetXInterface()->getAccessibleRowCount(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets total number of selected columns. + * + * @param columnCount the number of selected columns. + */ +STDMETHODIMP CAccTable::get_nSelectedColumns(long * columnCount) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(columnCount == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleColumns(); + *columnCount = pSelected.getLength(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets total number of selected rows. + * + * @param rowCount the number of selected rows. + */ +STDMETHODIMP CAccTable::get_nSelectedRows(long * rowCount) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(rowCount == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleRows(); + *rowCount = pSelected.getLength(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets accessible row description (as string). + * + * @param row the row index. + * @param description the description of the specified row. + */ +STDMETHODIMP CAccTable::get_rowDescription(long row, BSTR * description) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(description == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + const ::rtl::OUString& ouStr = GetXInterface()->getAccessibleRowDescription(row); + // #CHECK# + + SAFE_SYSFREESTRING(*description); + *description = SysAllocString((OLECHAR*)ouStr.getStr()); + if(description==NULL) + return E_FAIL; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets number of rows spanned by a table cell. + * + * @param row the row of the specified cell. + * @param column the column of the specified cell. + * @param spanRows the row span of the specified cell. + */ +STDMETHODIMP CAccTable::get_rowExtentAt(long row, long column, long * nRowsSpanned) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + XAccessibleTable *pXAccTable = GetXInterface(); + + // Check pointer. + if(nRowsSpanned == NULL) + return E_INVALIDARG; + + // Get Extent. + if(pXAccTable) + { + long lExt = GetXInterface()->getAccessibleRowExtentAt(row,column); + + // Fill Extent struct. + *nRowsSpanned= lExt; + + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets accessible row header. + * + * @param row the row index. + * @param accessible the accessible object of the row header. + */ +STDMETHODIMP CAccTable::get_rowHeader(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingColumnIndex) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(accessibleTable == NULL || startingColumnIndex == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleTable> pRRowHeaderTable = GetXInterface()->getAccessibleRowHeaders(); + if(!pRRowHeaderTable.is()) + { + *accessibleTable = NULL; + return E_FAIL; + } + + Reference<XAccessible> pRXRowHeader(pRRowHeaderTable,UNO_QUERY); + + if(!pRXRowHeader.is()) + { + *accessibleTable = NULL; + return E_FAIL; + } + *startingColumnIndex = 0 ; + + IAccessible* m_pIMacc = NULL; + ActivateActContext(); + HRESULT hr = CoCreateInstance( CLSID_MAccessible, NULL, CLSCTX_ALL , + IID_IMAccessible, + (void **)&m_pIMacc + ); + DeactivateActContext(); + ((CMAccessible*)m_pIMacc)->SetXAccessible((long)pRXRowHeader.get()); + m_pIMacc->QueryInterface(IID_IAccessibleTable,(void **)accessibleTable); + if( SUCCEEDED(hr) ) + { + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets list of row indexes currently selected (0-based). + * + * @param maxRows the max number of the rows. + * @param accessible the accessible object array of the selected rows. + * @param nRows the actual size of the accessible object array. + */ +STDMETHODIMP CAccTable::get_selectedRows(long, long ** rows, long * nRows) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(rows == NULL || nRows == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleRows(); + long count = pSelected.getLength() ; + *nRows = count; + + *rows = reinterpret_cast<long*>(CoTaskMemAlloc((count) * sizeof(long))); + // #CHECK Memory Allocation# + if(*rows == NULL) + { + return E_FAIL; + } + for(int i=0; i<count; i++) + (*rows)[i] = pSelected[i]; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets list of column indexes currently selected (0-based). + * + * @param maxColumns the max number of the columns. + * @param accessible the accessible object array of the selected columns. + * @param numColumns the actual size of accessible object array. + */ +STDMETHODIMP CAccTable::get_selectedColumns(long, long ** columns, long * numColumns) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(columns == NULL || numColumns == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleColumns(); + long count = pSelected.getLength() ; + *numColumns = count; + + *columns = reinterpret_cast<long*>(CoTaskMemAlloc((count) * sizeof(long))); + // #CHECK Memory Allocation# + if(*columns == NULL) + { + return E_FAIL; + } + for(int i=0; i<count; i++) + (*columns)[i] = pSelected[i]; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets accessible table summary. + * + * @param accessible the accessible object of the summary. + */ +STDMETHODIMP CAccTable::get_summary(IUnknown * * accessible) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(accessible == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + { + return E_FAIL; + } + Reference<XAccessible> pRAcc = GetXInterface()->getAccessibleSummary(); + + IAccessible* pRet = NULL; + BOOL isTRUE = CMAccessible::get_IAccessibleFromXAccessible((long)pRAcc.get(),&pRet); + + if(pRet) + { + *accessible = (IAccessible2 *)pRet; + pRet->AddRef(); + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Determines if table column is selected. + * + * @param column the column index. + * @param isSelected the result. + */ +STDMETHODIMP CAccTable::get_isColumnSelected(long column, unsigned char * isSelected) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(isSelected == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *isSelected = GetXInterface()->isAccessibleColumnSelected(column); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Determines if table row is selected. + * + * @param row the row index. + * @param isSelected the result. + */ +STDMETHODIMP CAccTable::get_isRowSelected(long row, unsigned char * isSelected) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(isSelected == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + { + return E_FAIL; + } + *isSelected = GetXInterface()->isAccessibleRowSelected(row); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Determines if table cell is selected. + * + * @param row the row index. + * @param column the column index. + * @param isSelected the result. + */ +STDMETHODIMP CAccTable::get_isSelected(long row, long column, unsigned char * isSelected) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(isSelected == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *isSelected = GetXInterface()->isAccessibleSelected(row,column); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Selects a row and unselect all previously selected rows. + * + * @param row the row index. + * @param success the result. + */ +STDMETHODIMP CAccTable::selectRow(long row) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // Check XAccessibleTable reference. + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleTableSelection> pRTableExtent(pRXTable, UNO_QUERY); + if(pRTableExtent.is()) + { + pRTableExtent.get()->selectRow(row); + return S_OK; + } + else + { + // Get XAccessibleSelection. + Reference<XAccessibleSelection> pRSelection(GetXInterface(), UNO_QUERY); + if(!pRSelection.is()) + return E_FAIL; + + // Select row. + long lCol, lColumnCount, lChildIndex; + lColumnCount = GetXInterface()->getAccessibleColumnCount(); + for(lCol = 0; lCol < lColumnCount; lCol ++) + { + lChildIndex = GetXInterface()->getAccessibleIndex(row, lCol); + pRSelection.get()->selectAccessibleChild(lChildIndex); + } + + return S_OK; + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Selects a column and unselect all previously selected columns. + * + * @param column the column index. + * @param success the result. + */ +STDMETHODIMP CAccTable::selectColumn(long column) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // Check XAccessibleTable reference. + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleTableSelection> pRTableExtent(GetXInterface(), UNO_QUERY); + if(pRTableExtent.is()) + { + pRTableExtent.get()->selectColumn(column); + return S_OK; + } + else + { + // Get XAccessibleSelection. + Reference<XAccessibleSelection> pRSelection(pRXTable, UNO_QUERY); + if(!pRSelection.is()) + return E_FAIL; + + // Select column. + long lRow, lRowCount, lChildIndex; + lRowCount = GetXInterface()->getAccessibleRowCount(); + for(lRow = 0; lRow < lRowCount; lRow ++) + { + lChildIndex = GetXInterface()->getAccessibleIndex(lRow, column); + pRSelection.get()->selectAccessibleChild(lChildIndex); + } + + return S_OK; + } + return S_OK; + // End of added. + + LEAVE_PROTECTED_BLOCK +} + +/** + * Unselects one row, leaving other selected rows selected (if any). + * + * @param row the row index. + * @param success the result. + */ +STDMETHODIMP CAccTable::unselectRow(long row) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // Check XAccessibleTable reference. + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleTableSelection> pRTableExtent(GetXInterface(), UNO_QUERY); + if(pRTableExtent.is()) + { + if(pRTableExtent.get()->unselectRow(row)) + return S_OK; + else + return E_FAIL; + } + else + { + // Get XAccessibleSelection. + Reference<XAccessibleSelection> pRSelection(pRXTable, UNO_QUERY); + if(!pRSelection.is()) + return E_FAIL; + + // Select column. + long lColumn, lColumnCount, lChildIndex; + lColumnCount = GetXInterface()->getAccessibleColumnCount(); + for(lColumn = 0; lColumn < lColumnCount; lColumn ++) + { + lChildIndex = GetXInterface()->getAccessibleIndex(row,lColumn); + pRSelection.get()->deselectAccessibleChild(lChildIndex); + } + + return S_OK; + } + return S_OK; + // End of added. + + LEAVE_PROTECTED_BLOCK +} + +/** + * Unselects one column, leaving other selected columns selected (if any). + * + * @param column the column index. + * @param success the result. + */ +STDMETHODIMP CAccTable::unselectColumn(long column) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // Check XAccessibleTable reference. + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleTableSelection> pRTableExtent(GetXInterface(), UNO_QUERY); + if(pRTableExtent.is()) + { + if(pRTableExtent.get()->unselectColumn(column)) + return S_OK; + else + return E_FAIL; + } + else + { + // Get XAccessibleSelection. + Reference<XAccessibleSelection> pRSelection(pRXTable, UNO_QUERY); + if(!pRSelection.is()) + return E_FAIL; + + // Unselect columns. + long lRow, lRowCount, lChildIndex; + lRowCount = GetXInterface()->getAccessibleRowCount(); + + for(lRow = 0; lRow < lRowCount; lRow ++) + { + lChildIndex = GetXInterface()->getAccessibleIndex(lRow, column); + pRSelection.get()->deselectAccessibleChild(lChildIndex); + } + return S_OK; + } + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Overide of IUNOXWrapper. + * + * @param pXInterface the pointer of UNO interface. + */ +STDMETHODIMP CAccTable::put_XInterface(long pXInterface) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + CUNOXWrapper::put_XInterface(pXInterface); + //special query. + if(pUNOInterface == NULL) + return E_INVALIDARG; + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + return E_FAIL; + + Reference<XAccessibleTable> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pRXTable = NULL; + else + pRXTable = pRXI.get(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Gets columnIndex of childIndex. + * + * @param childIndex childIndex + */ +STDMETHODIMP CAccTable::get_columnIndex(long childIndex, long * columnIndex) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(columnIndex == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *columnIndex = GetXInterface()->getAccessibleColumn(childIndex); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} +/** + * Gets rowIndex of childIndex. + * + * @param childIndex childIndex + */ +STDMETHODIMP CAccTable::get_rowIndex(long childIndex, long * rowIndex) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(rowIndex == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *rowIndex = GetXInterface()->getAccessibleRow(childIndex); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} +/** + * Gets childIndex of childIndex. + * + * @param childIndex childIndex + */ +STDMETHODIMP CAccTable::get_childIndex(long RowIndex , long columnIndex, long * childIndex ) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(childIndex == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + *childIndex = GetXInterface()->getAccessibleIndex(RowIndex, columnIndex); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CAccTable::get_rowColumnExtentsAtIndex(long, + long *, + long *, + long *, + long *, + boolean *) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CAccTable::get_modelChange(IA2TableModelChange *) +{ + + return E_NOTIMPL; +} + +// @brief Returns the total number of selected children +// @param [out] childCount +// Number of children currently selected +STDMETHODIMP CAccTable::get_nSelectedChildren(long *childCount) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(childCount == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleSelection> pRSelection(GetXInterface(), UNO_QUERY); + if(!pRSelection.is()) + return E_FAIL; + + *childCount = pRSelection->getSelectedAccessibleChildCount(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +// @brief Returns a list of child indexes currently selected (0-based). +// @param [in] maxChildren +// Max children requested (possibly from IAccessibleTable::nSelectedChildren) +// @param [out] children +// array of indexes of selected children (each index is 0-based) +// @param [out] nChildren +// Length of array (not more than maxChildren) +STDMETHODIMP CAccTable::get_selectedChildren(long, long **children, long *nChildren) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(children == NULL || nChildren == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if(!pRXTable.is()) + return E_FAIL; + + Reference<XAccessibleSelection> pRSelection(GetXInterface(), UNO_QUERY); + if(!pRSelection.is()) + return E_FAIL; + + long childCount = pRSelection->getSelectedAccessibleChildCount() ; + + *nChildren = childCount; + + *children = reinterpret_cast<long*>(CoTaskMemAlloc((childCount) * sizeof(long))); + + for( long i = 0; i< childCount; i++) + { + Reference<XAccessible> pRAcc = pRSelection->getSelectedAccessibleChild(i); + if(pRAcc.is()) + { + Reference<XAccessibleContext> pRContext(pRAcc, UNO_QUERY); + if( !pRContext.is() ) + return E_FAIL; + + long childIndex = pRContext->getAccessibleIndexInParent(); + (*children)[i] = childIndex; + } + } + + return S_OK; + + LEAVE_PROTECTED_BLOCK + +} |