| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| ////////////////////////////////////////////////////////////////////// |
| // AccActionBase.cpp: implementation of the CAccActionBase class. |
| ////////////////////////////////////////////////////////////////////// |
| #include "stdafx.h" |
| |
| #include "AccActionBase.h" |
| #include <com/sun/star/accessibility/XAccessible.hpp> |
| #include <com/sun/star/accessibility/AccessibleStateType.hpp> |
| #include <com/sun/star/accessibility/AccessibleRole.hpp> |
| #include <com/sun/star/accessibility/XAccessibleContext.hpp> |
| |
| #include "AccessibleKeyStroke.h" |
| |
| #ifndef __ACCCOMMON_H_ |
| #include "acccommon.h" |
| #endif |
| |
| using namespace com::sun::star::accessibility::AccessibleRole; |
| using namespace com::sun::star::accessibility; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::awt; |
| |
| ////////////////////////////////////////////////////////////////////// |
| // Construction/Destruction |
| ////////////////////////////////////////////////////////////////////// |
| |
| CAccActionBase::CAccActionBase() |
| {} |
| |
| CAccActionBase::~CAccActionBase() |
| {} |
| |
| /** |
| * Helper function used for getting default action by UNO role. |
| * |
| * @param pRContext UNO context interface pointer. |
| * @param pRet the corresponding string to be returned. |
| */ |
| void GetDfActionByUNORole(XAccessibleContext* pRContext, BSTR* pRet) |
| { |
| // #CHECK# |
| if(pRContext == NULL || pRet == NULL) |
| { |
| return; |
| } |
| |
| long Role = pRContext->getAccessibleRole(); |
| |
| switch(Role) |
| { |
| case PUSH_BUTTON: |
| *pRet = ::SysAllocString(PRESS); |
| break; |
| case RADIO_BUTTON: |
| case MENU_ITEM: |
| case LIST_ITEM: |
| *pRet = ::SysAllocString(SELECT); |
| break; |
| case CHECK_BOX: |
| { |
| Reference< XAccessibleStateSet > pRState = pRContext->getAccessibleStateSet(); |
| if( !pRState.is() ) |
| { |
| return; |
| } |
| |
| Sequence<short> pStates = pRState->getStates(); |
| int count = pStates.getLength(); |
| *pRet = ::SysAllocString(CHECK); |
| for( int iIndex = 0;iIndex < count;iIndex++ ) |
| { |
| if( pStates[iIndex] == AccessibleStateType::CHECKED ) |
| { |
| SAFE_SYSFREESTRING(*pRet); |
| *pRet = ::SysAllocString(UNCHECK); |
| break; |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Returns the number of action. |
| * |
| * @param nActions the number of action. |
| */ |
| STDMETHODIMP CAccActionBase::nActions(/*[out,retval]*/long* nActions) |
| { |
| |
| CHECK_ENABLE_INF |
| |
| ENTER_PROTECTED_BLOCK |
| |
| // #CHECK# |
| if( pRXAct.is() && nActions != NULL ) |
| { |
| *nActions = GetXInterface()->getAccessibleActionCount(); |
| return S_OK; |
| } |
| *nActions = 0; |
| |
| return S_OK; |
| |
| LEAVE_PROTECTED_BLOCK |
| } |
| |
| /** |
| * Performs specified action on the object. |
| * |
| * @param actionIndex the index of action. |
| */ |
| STDMETHODIMP CAccActionBase::doAction(/* [in] */ long actionIndex) |
| { |
| |
| CHECK_ENABLE_INF |
| |
| ENTER_PROTECTED_BLOCK |
| |
| if( pRXAct.is() ) |
| { |
| return GetXInterface()->doAccessibleAction( actionIndex )?S_OK:E_FAIL; |
| } |
| return E_FAIL; |
| |
| LEAVE_PROTECTED_BLOCK |
| } |
| |
| /** |
| * Gets description of specified action. |
| * |
| * @param actionIndex the index of action. |
| * @param description the description string of the specified action. |
| */ |
| STDMETHODIMP CAccActionBase::get_description(long actionIndex,BSTR __RPC_FAR *description) |
| { |
| |
| CHECK_ENABLE_INF |
| |
| ENTER_PROTECTED_BLOCK |
| |
| // #CHECK# |
| if(description == NULL) |
| return E_INVALIDARG; |
| |
| // #CHECK XInterface# |
| if(!pRXAct.is()) |
| return E_FAIL; |
| |
| ::rtl::OUString ouStr = GetXInterface()->getAccessibleActionDescription(actionIndex); |
| // #CHECK# |
| |
| SAFE_SYSFREESTRING(*description); |
| *description = SysAllocString((OLECHAR*)ouStr.getStr()); |
| |
| return S_OK; |
| |
| LEAVE_PROTECTED_BLOCK |
| } |
| |
| STDMETHODIMP CAccActionBase::get_name( long, BSTR __RPC_FAR *) |
| { |
| return E_NOTIMPL; |
| } |
| |
| STDMETHODIMP CAccActionBase::get_localizedName( long, BSTR __RPC_FAR *) |
| { |
| return E_NOTIMPL; |
| } |
| |
| /** |
| * Returns key binding object (if any) associated with specified action |
| * key binding is string. |
| * e.g. "alt+d" (like IAccessible::get_accKeyboardShortcut). |
| * |
| * @param actionIndex the index of action. |
| * @param nMaxBinding the max number of key binding. |
| * @param keyBinding the key binding array. |
| * @param nBinding the actual number of key binding returned. |
| */ |
| STDMETHODIMP CAccActionBase::get_keyBinding( |
| /* [in] */ long actionIndex, |
| /* [in] */ long, |
| /* [length_is][length_is][size_is][size_is][out] */ BSTR __RPC_FAR *__RPC_FAR *keyBinding, |
| /* [retval][out] */ long __RPC_FAR *nBinding) |
| { |
| |
| CHECK_ENABLE_INF |
| |
| ENTER_PROTECTED_BLOCK |
| |
| if( !keyBinding || !nBinding) |
| return E_INVALIDARG; |
| |
| if( !pRXAct.is() ) |
| return E_FAIL; |
| |
| Reference< XAccessibleKeyBinding > binding = GetXInterface()->getAccessibleActionKeyBinding(actionIndex); |
| if( !binding.is() ) |
| return E_FAIL; |
| |
| long nCount = (binding.get())->getAccessibleKeyBindingCount(); |
| |
| OLECHAR wString[64]; |
| |
| *keyBinding = (BSTR*)::CoTaskMemAlloc(nCount*sizeof(BSTR)); |
| |
| // #CHECK Memory Allocation# |
| if(*keyBinding == NULL) |
| return E_FAIL; |
| |
| for( int index = 0;index < nCount;index++ ) |
| { |
| memset(wString,0,sizeof(wString)); |
| GetkeyBindingStrByXkeyBinding( (binding.get())->getAccessibleKeyBinding(index), wString ); |
| |
| (*keyBinding)[index] = SysAllocString(wString); |
| } |
| |
| *nBinding = nCount; |
| return S_OK; |
| |
| LEAVE_PROTECTED_BLOCK |
| } |
| |
| /** |
| * Overide of IUNOXWrapper. |
| * |
| * @param pXInterface the pointer of UNO interface. |
| */ |
| STDMETHODIMP CAccActionBase::put_XInterface(long pXInterface) |
| { |
| |
| |
| ENTER_PROTECTED_BLOCK |
| |
| CUNOXWrapper::put_XInterface(pXInterface); |
| |
| //special query. |
| if(pUNOInterface == NULL) |
| return E_FAIL; |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); |
| if( !pRContext.is() ) |
| return E_FAIL; |
| |
| Reference<XAccessibleAction> pRXI(pRContext,UNO_QUERY); |
| if( !pRXI.is() ) |
| pRXAct = NULL; |
| else |
| pRXAct = pRXI.get(); |
| return S_OK; |
| |
| LEAVE_PROTECTED_BLOCK |
| } |
| |
| /** |
| * Helper function used for converting keybinding to string. |
| * |
| * @param keySet the key stroke sequence. |
| * @param pString the output keybinding string. |
| */ |
| void CAccActionBase::GetkeyBindingStrByXkeyBinding( const Sequence< KeyStroke > &keySet, OLECHAR* pString ) |
| { |
| // #CHECK# |
| if(pString == NULL) |
| return; |
| |
| for( int iIndex = 0;iIndex < keySet.getLength();iIndex++ ) |
| { |
| KeyStroke stroke = keySet[iIndex]; |
| OLECHAR wString[64] = {NULL}; |
| if(iIndex>0) |
| wcscat( wString, OLESTR(" ") ); |
| if((stroke.Modifiers & MODIFIER_SHIFT) == MODIFIER_SHIFT) |
| wcscat( wString, OLESTR("Shift+") ); |
| if((stroke.Modifiers & MODIFIER_CTRL) == MODIFIER_CTRL) |
| wcscat( wString, OLESTR("Ctrl+") ); |
| if((stroke.Modifiers & MODIFIER_ALT) == MODIFIER_ALT) |
| wcscat( wString, OLESTR("Alt+") ); |
| if(stroke.KeyCode) |
| { |
| OLECHAR* pChar = getOLECHARFromKeyCode(stroke.KeyCode); |
| if(pChar != NULL) |
| wcscat( wString, pChar ); |
| else if (stroke.KeyCode <= 255) |
| { |
| OLECHAR pChar[4] = {NULL}; |
| swprintf( pChar, L"%c", stroke.KeyCode); |
| wcscat( wString, pChar); |
| } |
| else |
| { |
| OLECHAR pChar[4] = {NULL}; |
| swprintf( pChar, L"%d", stroke.KeyCode); |
| wcscat( wString, pChar); |
| } |
| } |
| |
| wcscat( pString, wString); |
| } |
| } |
| |
| /** |
| * Helper function used for converting key code to ole string. |
| * |
| * @param key the key code. |
| */ |
| OLECHAR* CAccActionBase::getOLECHARFromKeyCode(long key) |
| { |
| static struct keyMap |
| { |
| int keyCode; |
| OLECHAR* key; |
| } |
| map[] = |
| { |
| {MODIFIER_SHIFT, L"SHIFT" }, |
| {MODIFIER_CTRL, L"CTRL" }, |
| {MODIFIER_ALT, L"ALT" }, |
| CODEENTRY(NUM0),CODEENTRY(NUM1),CODEENTRY(NUM2),CODEENTRY(NUM3),CODEENTRY(NUM4),CODEENTRY(NUM5), |
| CODEENTRY(NUM6),CODEENTRY(NUM7),CODEENTRY(NUM8),CODEENTRY(NUM9), |
| CODEENTRY(A),CODEENTRY(B),CODEENTRY(C),CODEENTRY(D),CODEENTRY(E),CODEENTRY(F), |
| CODEENTRY(G),CODEENTRY(H),CODEENTRY(I),CODEENTRY(J),CODEENTRY(K),CODEENTRY(L), |
| CODEENTRY(M),CODEENTRY(N),CODEENTRY(O),CODEENTRY(P),CODEENTRY(Q),CODEENTRY(R), |
| CODEENTRY(S),CODEENTRY(T),CODEENTRY(U),CODEENTRY(V),CODEENTRY(W),CODEENTRY(X), |
| CODEENTRY(Y),CODEENTRY(Z), |
| CODEENTRY(F1),CODEENTRY(F2),CODEENTRY(F3),CODEENTRY(F4),CODEENTRY(F5),CODEENTRY(F6), |
| CODEENTRY(F7),CODEENTRY(F8),CODEENTRY(F9),CODEENTRY(F10),CODEENTRY(F11),CODEENTRY(F12), |
| CODEENTRY(F13),CODEENTRY(F14),CODEENTRY(F15),CODEENTRY(F16),CODEENTRY(F17),CODEENTRY(F18), |
| CODEENTRY(F19),CODEENTRY(F20),CODEENTRY(F21),CODEENTRY(F22),CODEENTRY(F23),CODEENTRY(F24), |
| CODEENTRY(F25),CODEENTRY(F26), |
| |
| { KEYCODE_DOWN, L"DOWN" }, |
| { KEYCODE_UP, L"UP" }, |
| { KEYCODE_LEFT, L"LEFT" }, |
| { KEYCODE_RIGHT, L"RIGHT" }, |
| { KEYCODE_HOME, L"HOME" }, |
| { KEYCODE_END, L"END" }, |
| { KEYCODE_PAGEUP, L"PAGEUP" }, |
| { KEYCODE_PAGEDOWN, L"PAGEDOWN" }, |
| { KEYCODE_RETURN, L"RETURN" }, |
| { KEYCODE_ESCAPE, L"ESCAPE" }, |
| { KEYCODE_TAB, L"TAB" }, |
| { KEYCODE_BACKSPACE, L"BACKSPACE" }, |
| { KEYCODE_SPACE, L"SPACE" }, |
| { KEYCODE_INSERT, L"INSERT" }, |
| { KEYCODE_DELETE, L"DELETE" }, |
| { KEYCODE_ADD, L"ADD" }, |
| { KEYCODE_SUBTRACT, L"SUBTRACT" }, |
| { KEYCODE_MULTIPLY, L"MULTIPLY" }, |
| { KEYCODE_DIVIDE, L"DIVIDE" }, |
| { KEYCODE_POINT, L"POINT" }, |
| { KEYCODE_COMMA, L"COMMA" }, |
| { KEYCODE_LESS, L"LESS" }, |
| { KEYCODE_GREATER, L"GREATER" }, |
| { KEYCODE_EQUAL, L"EQUAL" }, |
| { KEYCODE_OPEN, L"OPEN" }, |
| { KEYCODE_CUT, L"CUT" }, |
| { KEYCODE_COPY, L"COPY" }, |
| { KEYCODE_PASTE, L"PASTE" }, |
| { KEYCODE_UNDO, L"UNDO" }, |
| { KEYCODE_REPEAT, L"REPEAT" }, |
| { KEYCODE_FIND, L"FIND" }, |
| { KEYCODE_PROPERTIES, L"PROPERTIES" }, |
| { KEYCODE_FRONT, L"FRONT" }, |
| { KEYCODE_CONTEXTMENU, L"CONTEXTMENU" }, |
| { KEYCODE_HELP, L"HELP" }, |
| }; |
| static long nCount = countof(map); |
| |
| long min = 0; |
| long max = nCount-1; |
| long mid = nCount/2; |
| while(min<max) |
| { |
| if(key<map[mid].keyCode) |
| max = mid-1; |
| else if(key>map[mid].keyCode) |
| min = mid+1; |
| else |
| break; |
| mid = (min+max)/2; |
| } |
| |
| if(key == map[mid].keyCode) |
| { |
| return map[mid].key; |
| } |
| else |
| { |
| return NULL; |
| } |
| } |
| |
