| /************************************************************** | |
| * | |
| * 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_PTR)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_PTR)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 caption. | |
| */ | |
| 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_PTR)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_PTR)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_PTR)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_PTR 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 | |
| } |