diff options
Diffstat (limited to 'winaccessibility/source/UAccCOM/AccActionBase.cpp')
| -rw-r--r-- | winaccessibility/source/UAccCOM/AccActionBase.cpp | 416 |
1 files changed, 416 insertions, 0 deletions
diff --git a/winaccessibility/source/UAccCOM/AccActionBase.cpp b/winaccessibility/source/UAccCOM/AccActionBase.cpp new file mode 100644 index 000000000000..bcad3c0df9c2 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccActionBase.cpp @@ -0,0 +1,416 @@ +/************************************************************** + * + * 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; + } +} + |