diff options
Diffstat (limited to 'winaccessibility/source/UAccCOM')
60 files changed, 11604 insertions, 0 deletions
diff --git a/winaccessibility/source/UAccCOM/AccAction.cxx b/winaccessibility/source/UAccCOM/AccAction.cxx new file mode 100644 index 000000000000..fe233f4ef3ab --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccAction.cxx @@ -0,0 +1,120 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +/** + * AccAction.cpp : Implementation of CAccAction + */ +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccAction.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +/** + * Returns the number of action. + * + * @param nActions the number of action. + */ +STDMETHODIMP CAccAction::nActions(/*[out,retval]*/long* nActions) +{ + + return CAccActionBase::nActions(nActions); +} + +/** + * Performs specified action on the object. + * + * @param actionIndex the index of action. + */ +STDMETHODIMP CAccAction::doAction(/* [in] */ long actionIndex) +{ + + return CAccActionBase::doAction(actionIndex); +} + +/** + * Gets description of specified action. + * + * @param actionIndex the index of action. + * @param description the description string of the specified action. + */ +STDMETHODIMP CAccAction::get_description(long actionIndex,BSTR __RPC_FAR *description) +{ + + return CAccActionBase::get_description(actionIndex, description); +} + +STDMETHODIMP CAccAction::get_name( long actionIndex, BSTR __RPC_FAR *name) +{ + + return CAccActionBase::get_name(actionIndex, name); +} + +STDMETHODIMP CAccAction::get_localizedName( long actionIndex, BSTR __RPC_FAR *localizedName) +{ + + return CAccActionBase::get_localizedName(actionIndex, localizedName); +} + +/** + * 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 CAccAction::get_keyBinding( + /* [in] */ long actionIndex, + /* [in] */ long nMaxBinding, + /* [length_is][length_is][size_is][size_is][out] */ BSTR __RPC_FAR *__RPC_FAR *keyBinding, + /* [retval][out] */ long __RPC_FAR *nBinding) +{ + + return CAccActionBase::get_keyBinding(actionIndex, nMaxBinding, keyBinding, nBinding); +} + +/** + * Overide of IUNOXWrapper. + * + * @param pXInterface the pointer of UNO interface. + */ +STDMETHODIMP CAccAction::put_XInterface(long pXInterface) +{ + + return CAccActionBase::put_XInterface(pXInterface); +} +/** + * Put UNO interface. + * @param pXSubInterface XAccessibleHyperlink interface. + * @return Result. +*/ +STDMETHODIMP CAccAction::put_XSubInterface(long pXSubInterface) +{ + + + pRXAct = (XAccessibleAction*)pXSubInterface; + + return S_OK; +} diff --git a/winaccessibility/source/UAccCOM/AccAction.h b/winaccessibility/source/UAccCOM/AccAction.h new file mode 100644 index 000000000000..01488b1dfbbc --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccAction.h @@ -0,0 +1,105 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __ACCACTION_H_ +#define __ACCACTION_H_ + +#include "resource.h" // main symbols +#include "AccActionBase.h" + +/** + * CAccAction implements IAccessibleAction interface. + */ +class ATL_NO_VTABLE CAccAction : + public CComObjectRoot, + public CComCoClass<CAccAction, &CLSID_AccAction>, + public IAccessibleAction, + public CAccActionBase +{ +public: + CAccAction() + { + + } + ~CAccAction() + { + + } + + DECLARE_REGISTRY_RESOURCEID(IDR_ACCACTION) + + BEGIN_COM_MAP(CAccAction) + COM_INTERFACE_ENTRY(IAccessibleAction) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccAction*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + // IAccessibleAction +public: + // IAccessibleAction + + // Returns the number of action. + STDMETHOD(nActions)(/*[out,retval]*/long* nActions); + + // Performs specified action on the object. + STDMETHOD(doAction)(/* [in] */ long actionIndex); + + // Gets description of specified action. + STDMETHOD(get_description)(long actionIndex,BSTR __RPC_FAR *description); + + // added , 2006/06/28, for driver 07/11 + // get the action name + STDMETHOD(get_name)( long actionIndex, BSTR __RPC_FAR *name); + + // get the localized action name + STDMETHOD(get_localizedName)( long actionIndex, BSTR __RPC_FAR *localizedName); + + // Returns key binding object (if any) associated with specified action + // key binding is string. + // e.g. "alt+d" (like IAccessible::get_accKeyboardShortcut). + STDMETHOD(get_keyBinding)( + /* [in] */ long actionIndex, + /* [in] */ long nMaxBinding, + /* [length_is][length_is][size_is][size_is][out] */ BSTR __RPC_FAR *__RPC_FAR *keyBinding, + /* [retval][out] */ long __RPC_FAR *nBinding); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XSubInterface)(long pXSubInterface); + +}; + +#endif //__ACCACTION_H_ diff --git a/winaccessibility/source/UAccCOM/AccAction.rgs b/winaccessibility/source/UAccCOM/AccAction.rgs new file mode 100644 index 000000000000..7b51e7b701cf --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccAction.rgs @@ -0,0 +1,26 @@ +HKCR +{ + UAccCOM.AccAction.1 = s 'AccAction Class' + { + CLSID = s '{AA49F20E-BB4E-400D-A5B0-6F5B7B770227}' + } + UAccCOM.AccAction = s 'AccAction Class' + { + CLSID = s '{AA49F20E-BB4E-400D-A5B0-6F5B7B770227}' + CurVer = s 'UAccCOM.AccAction.1' + } + NoRemove CLSID + { + ForceRemove {AA49F20E-BB4E-400D-A5B0-6F5B7B770227} = s 'AccAction Class' + { + ProgID = s 'UAccCOM.AccAction.1' + VersionIndependentProgID = s 'UAccCOM.AccAction' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + 'TypeLib' = s '{19ECB1B0-9376-4FF9-B580-223FC9C200B8}' + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccActionBase.cxx b/winaccessibility/source/UAccCOM/AccActionBase.cxx new file mode 100644 index 000000000000..bcad3c0df9c2 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccActionBase.cxx @@ -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; + } +} + diff --git a/winaccessibility/source/UAccCOM/AccActionBase.h b/winaccessibility/source/UAccCOM/AccActionBase.h new file mode 100644 index 000000000000..349bd49ad6d8 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccActionBase.h @@ -0,0 +1,92 @@ +/************************************************************** + * + * 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.h: interface for the CAccActionBase class. +////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_ACCACTIONBASE_H__F87FAD24_D66E_4D22_9B24_3304A303DC84__INCLUDED_) +#define AFX_ACCACTIONBASE_H__F87FAD24_D66E_4D22_9B24_3304A303DC84__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WNT + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleAction.hpp> +#include "UNOXWrapper.h" + +class ATL_NO_VTABLE CAccActionBase : public CUNOXWrapper +{ +public: + CAccActionBase(); + virtual ~CAccActionBase(); + + // IAccessibleAction +public: + // IAccessibleAction + + // Returns the number of action. + STDMETHOD(nActions)(/*[out,retval]*/long* nActions); + + // Performs specified action on the object. + STDMETHOD(doAction)(/* [in] */ long actionIndex); + + // Gets description of specified action. + STDMETHOD(get_description)(long actionIndex,BSTR __RPC_FAR *description); + + // added , 2006/06/28, for driver 07/11 + // get the action name + STDMETHOD(get_name)( long actionIndex, BSTR __RPC_FAR *name); + + // get the localized action Name + STDMETHOD(get_localizedName)( long actionIndex, BSTR __RPC_FAR *localizedName); + + // Returns key binding object (if any) associated with specified action + // key binding is string. + // e.g. "alt+d" (like IAccessible::get_accKeyboardShortcut). + STDMETHOD(get_keyBinding)( + /* [in] */ long actionIndex, + /* [in] */ long nMaxBinding, + /* [length_is][length_is][size_is][size_is][out] */ BSTR __RPC_FAR *__RPC_FAR *keyBinding, + /* [retval][out] */ long __RPC_FAR *nBinding); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + + static void GetkeyBindingStrByXkeyBinding( const com::sun::star::uno::Sequence< com::sun::star::awt::KeyStroke > &keySet, OLECHAR* pString ); + +protected: + + static OLECHAR* getOLECHARFromKeyCode(long key); + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleAction> pRXAct; + +private: + inline com::sun::star::accessibility::XAccessibleAction* GetXInterface() + { + return pRXAct.get(); + } +}; + +#endif // !defined(AFX_ACCACTIONBASE_H__F87FAD24_D66E_4D22_9B24_3304A303DC84__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccComponent.cxx b/winaccessibility/source/UAccCOM/AccComponent.cxx new file mode 100644 index 000000000000..b209ea5006db --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccComponent.cxx @@ -0,0 +1,72 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +/** + * AccComponent.cpp : Implementation of CUAccCOMApp and DLL registration. + */ +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccComponent.h" + +/** + * Returns the location of the upper left corner of the object's bounding + * box relative to the parent. + * + * @param Location the upper left corner of the object's bounding box. + */ +STDMETHODIMP CAccComponent::get_locationInParent(long *x, long *y) +{ + + return CAccComponentBase::get_locationInParent(x,y); +} + +/** + * Returns the foreground color of this object. + * + * @param Color the color of foreground. + */ +STDMETHODIMP CAccComponent::get_foreground(IA2Color * foreground) +{ + + return CAccComponentBase::get_foreground(foreground); +} + +/** + * Returns the background color of this object. + * + * @param Color the color of background. + */ +STDMETHODIMP CAccComponent::get_background(IA2Color * background) +{ + + return CAccComponentBase::get_background(background); +} + +/** + * Overide of IUNOXWrapper. + * + * @param pXInterface the pointer of UNO interface. + */ +STDMETHODIMP CAccComponent::put_XInterface(long pXInterface) +{ + + return CAccComponentBase::put_XInterface(pXInterface); +} diff --git a/winaccessibility/source/UAccCOM/AccComponent.h b/winaccessibility/source/UAccCOM/AccComponent.h new file mode 100644 index 000000000000..6544bbf273e4 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccComponent.h @@ -0,0 +1,97 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCCOMPONENT_H__626D760C_3944_4B0E_BB4D_F0D20AEDF7DC__INCLUDED_) +#define AFX_ACCCOMPONENT_H__626D760C_3944_4B0E_BB4D_F0D20AEDF7DC__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" // main symbols + +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include <com/sun/star/accessibility/XAccessibleComponent.hpp> +#include "UNOXWrapper.h" +#include "AccComponentBase.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +/** + * CAccComponent implements IAccessibleComponent interface. + */ +class ATL_NO_VTABLE CAccComponent : + public CComObjectRoot, + public CComCoClass<CAccComponent,&CLSID_AccComponent>, + public IAccessibleComponent, + public CAccComponentBase +{ +public: + CAccComponent() + { + } + ~CAccComponent() + { + } + + BEGIN_COM_MAP(CAccComponent) + COM_INTERFACE_ENTRY(IAccessibleComponent) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccComponent*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_AccComponent) + + // IAccessibleComponent +public: + // IAccessibleComponent + + // Returns the location of the upper left corner of the object's bounding + // box relative to the parent. + STDMETHOD(get_locationInParent)(long *x, long *y); + + // Returns the foreground color of this object. + STDMETHOD(get_foreground)(IA2Color * foreground); + + // Returns the background color of this object. + STDMETHOD(get_background)(IA2Color * background); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +}; + +#endif // !defined(AFX_ACCCOMPONENT_H__626D760C_3944_4B0E_BB4D_F0D20AEDF7DC__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccComponent.rgs b/winaccessibility/source/UAccCOM/AccComponent.rgs new file mode 100644 index 000000000000..ee87c169e969 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccComponent.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccComponent.1 = s 'AccComponent Class' + { + CLSID = s '{9FD9BA47-70AF-4160-99F1-526F2B9F111B}' + } + UAccCOM.AccComponent = s 'AccComponent Class' + { + CLSID = s '{9FD9BA47-70AF-4160-99F1-526F2B9F111B}' + } + NoRemove CLSID + { + ForceRemove {9FD9BA47-70AF-4160-99F1-526F2B9F111B} = s 'AccComponent Class' + { + ProgID = s 'UAccCOM.AccComponent.1' + VersionIndependentProgID = s 'UAccCOM.AccComponent' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccComponentBase.cxx b/winaccessibility/source/UAccCOM/AccComponentBase.cxx new file mode 100644 index 000000000000..234177e62d7d --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccComponentBase.cxx @@ -0,0 +1,213 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "AccComponentBase.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include "MAccessible.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +CAccComponentBase::CAccComponentBase() +{} + +CAccComponentBase::~CAccComponentBase() +{} + + +/** + * Returns the location of the upper left corner of the object's bounding + * box relative to the parent. + * + * @param Location the upper left corner of the object's bounding box. + */ +STDMETHODIMP CAccComponentBase::get_locationInParent(long *x, long *y) +{ + + CHECK_ENABLE_INF + + try + { + if (x == NULL || y == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXComp.is()) + return E_FAIL; + + const ::com::sun::star::awt::Point& pt = GetXInterface()->getLocation(); + *x = pt.X; + *y = pt.Y; + return S_OK; + } + catch(...) + { + return E_FAIL; + } +} + +/** + * Returns the location of the upper left corner of the object's bounding + * box in screen. + * + * @param Location the upper left corner of the object's bounding + * box in screen coordinates. + */ +STDMETHODIMP CAccComponentBase::get_locationOnScreen(long *x, long *y) +{ + + CHECK_ENABLE_INF + + try + { + if (x == NULL || y == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXComp.is()) + return E_FAIL; + + const ::com::sun::star::awt::Point& pt = GetXInterface()->getLocationOnScreen(); + *x = pt.X; + *y = pt.Y; + return S_OK; + + } + catch(...) + { + return E_FAIL; + } +} + +/** + * Grabs the focus to this object. + * + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccComponentBase::grabFocus(boolean * success) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (success == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXComp.is()) + { + return E_FAIL; + } + GetXInterface()->grabFocus(); + *success = TRUE; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Returns the foreground color of this object. + * + * @param Color the color of foreground. + */ +STDMETHODIMP CAccComponentBase::get_foreground(IA2Color * foreground) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (foreground == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXComp.is()) + { + return E_FAIL; + } + *foreground = (long)GetXInterface()->getForeground(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Returns the background color of this object. + * + * @param Color the color of background. + */ +STDMETHODIMP CAccComponentBase::get_background(IA2Color * background) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (background == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXComp.is()) + { + return E_FAIL; + } + *background = (long)GetXInterface()->getBackground(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Overide of IUNOXWrapper. + * + * @param pXInterface the pointer of UNO interface. + */ +STDMETHODIMP CAccComponentBase::put_XInterface(long pXInterface) +{ + + CHECK_ENABLE_INF + + 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<XAccessibleComponent> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pRXComp = NULL; + else + pRXComp = pRXI.get(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} diff --git a/winaccessibility/source/UAccCOM/AccComponentBase.h b/winaccessibility/source/UAccCOM/AccComponentBase.h new file mode 100644 index 000000000000..6eed5782be91 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccComponentBase.h @@ -0,0 +1,78 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +////////////////////////////////////////////////////////////////////// +// AccComponentBase.h: interface for the CAccComponentBase class. +////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_ACCCOMPONENTBASE_H__946BE230_1DCB_494B_ACF6_32A2E197DD2A__INCLUDED_) +#define AFX_ACCCOMPONENTBASE_H__946BE230_1DCB_494B_ACF6_32A2E197DD2A__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WNT + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleComponent.hpp> +#include "UNOXWrapper.h" + +class ATL_NO_VTABLE CAccComponentBase : public CUNOXWrapper +{ +public: + CAccComponentBase(); + virtual ~CAccComponentBase(); + // IAccessibleComponent +public: + // IAccessibleComponent + + // Returns the location of the upper left corner of the object's bounding + // box relative to the parent. + STDMETHOD(get_locationInParent)(long *x, long *y); + + // Returns the location of the upper left corner of the object's bounding + // box in screen. + STDMETHOD(get_locationOnScreen)(long *x, long *y); + + // Grabs the focus to this object. + STDMETHOD(grabFocus)(boolean * success); + + // Returns the foreground color of this object. + STDMETHOD(get_foreground)(IA2Color * foreground); + + // Returns the background color of this object. + STDMETHOD(get_background)(IA2Color * background); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +protected: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleComponent> pRXComp; + + inline com::sun::star::accessibility::XAccessibleComponent* GetXInterface() + { + return pRXComp.get(); + } +}; + +#endif // !defined(AFX_ACCCOMPONENTBASE_H__946BE230_1DCB_494B_ACF6_32A2E197DD2A__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccContext.rgs b/winaccessibility/source/UAccCOM/AccContext.rgs new file mode 100644 index 000000000000..b3e9e3a081da --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccContext.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccContext.1 = s 'AccContext Class' + { + CLSID = s '{F77CAEC2-F04C-4E74-A36C-F3B557BC59E1}' + } + UAccCOM.AccContext = s 'AccContext Class' + { + CLSID = s '{F77CAEC2-F04C-4E74-A36C-F3B557BC59E1}' + } + NoRemove CLSID + { + ForceRemove {F77CAEC2-F04C-4E74-A36C-F3B557BC59E1} = s 'AccContext Class' + { + ProgID = s 'UAccCOM.AccContext.1' + VersionIndependentProgID = s 'UAccCOM.AccContext' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccEditableText.cxx b/winaccessibility/source/UAccCOM/AccEditableText.cxx new file mode 100644 index 000000000000..2dce3b8e111a --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccEditableText.cxx @@ -0,0 +1,508 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +/** + * AccEditableText.cpp : Implementation of CUAccCOMApp and DLL registration. + */ +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccEditableText.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include <com/sun/star/accessibility/XAccessibleText.hpp> +#include <com/sun/star/awt/FontSlant.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/style/LineSpacing.hpp> +#include <com/sun/star/style/TabStop.hpp> +#include <vector> + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; +using namespace com::sun::star::awt; +using namespace com::sun::star::beans; +using namespace std; + +/** + * Copys a range of text to the clipboard. + * + * @param startOffset the start offset of copying. + * @param endOffset the end offset of copying. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::copyText(long startOffset, long endOffset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK XInterface# + if(!pRXEdtTxt.is()) + { + return E_FAIL; + } + + if ( GetXInterface()->copyText( startOffset, endOffset ) ) + return S_OK; + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Deletes a range of text. + * + * @param startOffset the start offset of deleting. + * @param endOffset the end offset of deleting. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::deleteText(long startOffset, long endOffset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if( !pRXEdtTxt.is() ) + return E_FAIL; + + if( GetXInterface()->deleteText( startOffset, endOffset ) ) + return S_OK; + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Inserts text at a specified offset. + * + * @param offset the offset of inserting. + * @param text the text to be inserted. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::insertText(long offset, BSTR * text) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (text == NULL) + return E_INVALIDARG; + + if( !pRXEdtTxt.is() ) + return E_FAIL; + + ::rtl::OUString ouStr(*text); + + if( GetXInterface()->insertText( ouStr, offset ) ) + return S_OK; + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Cuts a range of text to the clipboard. + * + * @param startOffset the start offset of cuting. + * @param endOffset the end offset of cuting. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::cutText(long startOffset, long endOffset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if( !pRXEdtTxt.is() ) + return E_FAIL; + + if( GetXInterface()->cutText( startOffset, endOffset ) ) + return S_OK; + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Pastes text from clipboard at specified offset. + * + * @param offset the offset of pasting. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::pasteText(long offset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if( !pRXEdtTxt.is() ) + return E_FAIL; + + if( GetXInterface()->pasteText( offset ) ) + return S_OK; + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Replaces range of text with new text. + * + * @param startOffset the start offset of replacing. + * @param endOffset the end offset of replacing. + * @param text the replacing text. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::replaceText(long startOffset, long endOffset, BSTR * text) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if (text == NULL) + return E_INVALIDARG; + if( !pRXEdtTxt.is() ) + return E_FAIL; + + ::rtl::OUString ouStr(*text); + + if( GetXInterface()->replaceText( startOffset,endOffset, ouStr) ) + return S_OK; + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Sets attributes of range of text. + * + * @param startOffset the start offset. + * @param endOffset the end offset. + * @param attributes the attribute text. + * @param success the boolean result to be returned. + */ +STDMETHODIMP CAccEditableText::setAttributes(long startOffset, long endOffset, BSTR * attributes) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if (attributes == NULL) + return E_INVALIDARG; + if( !pRXEdtTxt.is() ) + return E_FAIL; + + ::rtl::OUString ouStr(*attributes); + + sal_Int32 nIndex = 0; + sal_Unicode cTok = ';'; + vector< ::rtl::OUString > vecAttr; + do + { + ::rtl::OUString ouToken = ouStr.getToken(0, cTok, nIndex); + vecAttr.push_back(ouToken); + } + while(nIndex >= 0); + + Sequence< PropertyValue > beanSeq(vecAttr.size()); + for(unsigned int i = 0; i < vecAttr.size(); i ++) + { + ::rtl::OUString attr = vecAttr[i]; + sal_Int32 nPos = attr.indexOf(':'); + if(nPos > -1) + { + ::rtl::OUString attrName = attr.copy(0, nPos); + ::rtl::OUString attrValue = attr.copy(nPos + 1, attr.getLength() - nPos - 1); + beanSeq[i].Name = attrName; + get_AnyFromOLECHAR(attrName, attrValue, beanSeq[i].Value); + } + } + + if( GetXInterface()->setAttributes( startOffset,endOffset, beanSeq) ) + return S_OK; + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Convert attributes string to Any type. + * Reference to infra\accessibility\bridge\org\openoffice\java\accessibility\AccessibleTextImpl.java + * + * @param ouName the string of attribute name. + * @param ouValue the string of attribute value. + * @param rAny the Any object to be returned. + */ +void CAccEditableText::get_AnyFromOLECHAR(const ::rtl::OUString &ouName, const ::rtl::OUString &ouValue, Any &rAny) +{ + if(ouName.compareTo(L"CharBackColor") == 0 || + ouName.compareTo(L"CharColor") == 0 || + ouName.compareTo(L"ParaAdjust") == 0 || + ouName.compareTo(L"ParaFirstLineIndent") == 0 || + ouName.compareTo(L"ParaLeftMargin") == 0 || + ouName.compareTo(L"ParaRightMargin") == 0 || + ouName.compareTo(L"ParaTopMargin") == 0 || + ouName.compareTo(L"ParaBottomMargin") == 0 || + ouName.compareTo(L"CharFontPitch") == 0) + { + // Convert to int. + // NOTE: CharFontPitch is not implemented in java file. + sal_Int32 nValue = ouValue.toInt32(); + rAny.setValue(&nValue, getCppuType((sal_Int32 *)0)); + } + else if(ouName.compareTo(L"CharShadowed") == 0 || + ouName.compareTo(L"CharContoured") == 0) + { + // Convert to boolean. + boolean nValue = (boolean)ouValue.toBoolean(); + rAny.setValue(&nValue, getCppuType((sal_Bool *)sal_False)); + } + else if(ouName.compareTo(L"CharEscapement") == 0 || + ouName.compareTo(L"CharStrikeout") == 0 || + ouName.compareTo(L"CharUnderline") == 0 || + ouName.compareTo(L"CharFontPitch") == 0) + { + // Convert to short. + short nValue = (short)ouValue.toInt32(); + rAny.setValue(&nValue, getCppuType((short *)0)); + } + else if(ouName.compareTo(L"CharHeight") == 0 || + ouName.compareTo(L"CharWeight") == 0) + { + // Convert to float. + float fValue = ouValue.toFloat(); + rAny.setValue(&fValue, getCppuType((float *)0)); + } + else if(ouName.compareTo(L"CharFontName") == 0) + { + // Convert to string. + rAny.setValue(&ouValue, getCppuType((::rtl::OUString *)0)); + } + else if(ouName.compareTo(L"CharPosture") == 0) + { + // Convert to FontSlant. + ::com::sun::star::awt::FontSlant fontSlant = (::com::sun::star::awt::FontSlant)ouValue.toInt32(); + rAny.setValue(&fontSlant, getCppuType((::com::sun::star::awt::FontSlant*)0)); + } + else if(ouName.compareTo(L"ParaTabStops") == 0) + { + // + // Convert to the Sequence with TabStop element. + vector< ::com::sun::star::style::TabStop > vecTabStop; + ::com::sun::star::style::TabStop tabStop; + ::rtl::OUString ouSubValue; + sal_Int32 nIndex = 0; + sal_Int32 pos = 0, posComma = 0; + + do + { + // Position. + pos = ouValue.indexOf(L"Position=", pos); + if(pos != -1) + { + posComma = ouValue.indexOf(',', pos + 9); // 9 = length of "Position=". + if(posComma != -1) + { + ouSubValue = ouValue.copy(pos + 9, posComma - pos - 9); + tabStop.Position = ouSubValue.toInt32(); + pos = posComma + 1; + + // TabAlign. + pos = ouValue.indexOf(L"TabAlign=", pos); + if(pos != -1) + { + posComma = ouValue.indexOf(',', pos + 9); // 9 = length of "TabAlign=". + if(posComma != -1) + { + ouSubValue = ouValue.copy(pos + 9, posComma - pos - 9); + tabStop.Alignment = (::com::sun::star::style::TabAlign)ouSubValue.toInt32(); + pos = posComma + 1; + + // DecimalChar. + pos = ouValue.indexOf(L"DecimalChar=", pos); + if(pos != -1) + { + posComma = ouValue.indexOf(',', pos + 11); // 11 = length of "TabAlign=". + if(posComma != -1) + { + ouSubValue = ouValue.copy(pos + 11, posComma - pos - 11); + tabStop.DecimalChar = (sal_Unicode)ouSubValue.toChar(); + pos = posComma + 1; + + // FillChar. + pos = ouValue.indexOf(L"FillChar=", pos); + if(pos != -1) + { + posComma = ouValue.indexOf(',', pos + 9); // 9 = length of "TabAlign=". + if(posComma != -1) + { + ouSubValue = ouValue.copy(pos + 9, posComma - pos - 9); + tabStop.DecimalChar = (sal_Unicode)ouSubValue.toChar(); + pos = posComma + 1; + + // Complete TabStop element. + vecTabStop.push_back(tabStop); + } + else + break; // No match comma. + } + else + break; // No match FillChar. + } + else + break; // No match comma. + } + else + break; // No match DecimalChar. + } + else + break; // No match comma. + } + else + break; // No match TabAlign. + } + else + break; // No match comma. + } + else + break; // No match Position. + } + while(pos < ouValue.getLength()); + + // + // Dump into Sequence. + int iSeqLen = (vecTabStop.size() == 0) ? 1 : vecTabStop.size(); + Sequence< ::com::sun::star::style::TabStop > seqTabStop(iSeqLen); + + if(vecTabStop.size() != 0) + { + // Dump every element. + for(int i = 0; i < iSeqLen; i ++) + { + seqTabStop[i] = vecTabStop[i]; + } + } + else + { + // Create default value. + seqTabStop[0].Position = 0; + seqTabStop[0].Alignment = ::com::sun::star::style::TabAlign_DEFAULT; + seqTabStop[0].DecimalChar = '.'; + seqTabStop[0].FillChar = ' '; + } + + // Assign to Any object. + rAny.setValue(&seqTabStop, getCppuType((Sequence< ::com::sun::star::style::TabStop >*)0)); + } + else if(ouName.compareTo(L"ParaLineSpacing") == 0) + { + // Parse value string. + ::com::sun::star::style::LineSpacing lineSpacing; + ::rtl::OUString ouSubValue; + sal_Int32 pos = 0, posComma = 0; + + pos = ouValue.indexOf(L"Mode=", pos); + if(pos != -1) + { + posComma = ouValue.indexOf(',', pos + 5); // 5 = length of "Mode=". + if(posComma != -1) + { + ouSubValue = ouValue.copy(pos + 5, posComma - pos - 5); + lineSpacing.Mode = (sal_Int16)ouSubValue.toInt32(); + pos = posComma + 1; + + pos = ouValue.indexOf(L"Height=", pos); + if(pos != -1) + { + ouSubValue = ouValue.copy(pos + 7, ouValue.getLength() - pos - 7); + lineSpacing.Height = (sal_Int16)ouSubValue.toInt32(); + } + else + { + lineSpacing.Height = (sal_Int16)100; // Default height. + } + } + else + { + lineSpacing.Height = (sal_Int16)100; // Default height. + } + } + else + { + // Default Mode and Height. + lineSpacing.Mode = (sal_Int16)0; + lineSpacing.Height = (sal_Int16)100; // Default height. + } + + // Convert to Any object. + rAny.setValue(&lineSpacing, getCppuType((::com::sun::star::style::LineSpacing* )0)); + } + else + { + // Do nothing. + sal_Int32 nDefault = 0; + rAny.setValue(&nDefault, getCppuType((sal_Int32 *)0)); + } +} + +/** + * Overide of IUNOXWrapper. + * + * @param pXInterface the pointer of UNO interface. + */ +STDMETHODIMP CAccEditableText::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<XAccessibleEditableText> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pRXEdtTxt = NULL; + else + pRXEdtTxt = pRXI.get(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} diff --git a/winaccessibility/source/UAccCOM/AccEditableText.h b/winaccessibility/source/UAccCOM/AccEditableText.h new file mode 100644 index 000000000000..8542a740a5ee --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccEditableText.h @@ -0,0 +1,115 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCEDITABLETEXT_H__0C41AFBE_5A87_4D9D_A284_CEC264D91F81__INCLUDED_) +#define AFX_ACCEDITABLETEXT_H__0C41AFBE_5A87_4D9D_A284_CEC264D91F81__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleEditableText.hpp> +#include "UNOXWrapper.h" + +/** + * CAccEditableText implements IAccessibleEditableText interface. + */ +class CAccEditableText : + public CComObjectRoot, + public CComCoClass<CAccEditableText,&CLSID_AccEditableText>, + public IAccessibleEditableText, + public CUNOXWrapper +{ +public: + CAccEditableText() + { + + } + virtual ~CAccEditableText() + { + + } + + BEGIN_COM_MAP(CAccEditableText) + COM_INTERFACE_ENTRY(IAccessibleEditableText) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccEditableText*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_AccEditableText) + + // IAccessibleEditableText +public: + // IAccessibleEditableText + + // Copys a range of text to the clipboard. + STDMETHOD(copyText)(long startOffset, long endOffset); + + // Deletes a range of text. + STDMETHOD(deleteText)(long startOffset, long endOffset); + + // Inserts text at a specified offset. + STDMETHOD(insertText)(long offset, BSTR * text); + + // Cuts a range of text to the clipboard. + STDMETHOD(cutText)(long startOffset, long endOffset); + + // Pastes text from clipboard at specified offset. + STDMETHOD(pasteText)(long offset); + + // Replaces range of text with new text. + STDMETHOD(replaceText)(long startOffset, long endOffset, BSTR * text); + + + // Sets attributes of range of text. + STDMETHOD(setAttributes)(long startOffset, long endOffset, BSTR * attributes); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleEditableText> pRXEdtTxt; + + void get_AnyFromOLECHAR(const ::rtl::OUString &ouName, const ::rtl::OUString &ouValue, com::sun::star::uno::Any &rAny); + + inline com::sun::star::accessibility::XAccessibleEditableText* GetXInterface() + { + return pRXEdtTxt.get(); + } +}; + +#endif // !defined(AFX_ACCEDITABLETEXT_H__0C41AFBE_5A87_4D9D_A284_CEC264D91F81__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccEditableText.rgs b/winaccessibility/source/UAccCOM/AccEditableText.rgs new file mode 100644 index 000000000000..03aacb325719 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccEditableText.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccEditableText.1 = s 'AccEditableText Class' + { + CLSID = s '{79CE1450-1F61-48E2-BF76-C07BD10105E2}' + } + UAccCOM.AccEditableText = s 'AccEditableText Class' + { + CLSID = s '{79CE1450-1F61-48E2-BF76-C07BD10105E2}' + } + NoRemove CLSID + { + ForceRemove {79CE1450-1F61-48E2-BF76-C07BD10105E2} = s 'AccEditableText Class' + { + ProgID = s 'UAccCOM.AccEditableText.1' + VersionIndependentProgID = s 'UAccCOM.AccEditableText' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccExtendedComponent.rgs b/winaccessibility/source/UAccCOM/AccExtendedComponent.rgs new file mode 100644 index 000000000000..6039885b357d --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccExtendedComponent.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccExtendedComponent.1 = s 'AccExtendedComponent Class' + { + CLSID = s '{D91562E1-BE6C-41F3-A34C-E7AA846561A4}' + } + UAccCOM.AccExtendedComponent = s 'AccExtendedComponent Class' + { + CLSID = s '{D91562E1-BE6C-41F3-A34C-E7AA846561A4}' + } + NoRemove CLSID + { + ForceRemove {D91562E1-BE6C-41F3-A34C-E7AA846561A4} = s 'AccExtendedComponent Class' + { + ProgID = s 'UAccCOM.AccExtendedComponent.1' + VersionIndependentProgID = s 'UAccCOM.AccExtendedComponent' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccFont.rgs b/winaccessibility/source/UAccCOM/AccFont.rgs new file mode 100644 index 000000000000..c229746dbca6 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccFont.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccFont.1 = s 'AccFont Class' + { + CLSID = s '{185B9AD9-5D31-4793-888F-A21846BBAEDD}' + } + UAccCOM.AccFont = s 'AccFont Class' + { + CLSID = s '{185B9AD9-5D31-4793-888F-A21846BBAEDD}' + } + NoRemove CLSID + { + ForceRemove {185B9AD9-5D31-4793-888F-A21846BBAEDD} = s 'AccFont Class' + { + ProgID = s 'UAccCOM.AccFont.1' + VersionIndependentProgID = s 'UAccCOM.AccFont' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccHyperLink.cxx b/winaccessibility/source/UAccCOM/AccHyperLink.cxx new file mode 100644 index 000000000000..b63ccd09e246 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccHyperLink.cxx @@ -0,0 +1,296 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccHyperLink.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleAction.hpp> +#include "MAccessible.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; +using namespace com::sun::star::awt; + +/** + * Returns the number of action. + * + * @param nActions the number of action. + */ +STDMETHODIMP CAccHyperLink::nActions(/*[out,retval]*/long* nActions) +{ + + return CAccActionBase::nActions(nActions); +} + +/** + * Performs specified action on the object. + * + * @param actionIndex the index of action. + */ +STDMETHODIMP CAccHyperLink::doAction(/* [in] */ long actionIndex) +{ + + return CAccActionBase::doAction(actionIndex); +} + +/** + * Gets description of specified action. + * + * @param actionIndex the index of action. + * @param description the description string of the specified action. + */ +STDMETHODIMP CAccHyperLink::get_description(long actionIndex,BSTR __RPC_FAR *description) +{ + + return CAccActionBase::get_description(actionIndex, description); +} + +STDMETHODIMP CAccHyperLink::get_name( long actionIndex, BSTR __RPC_FAR *name) +{ + + return CAccActionBase::get_name(actionIndex, name); +} + +STDMETHODIMP CAccHyperLink::get_localizedName( long actionIndex, BSTR __RPC_FAR *localizedName) +{ + + return CAccActionBase::get_name(actionIndex, localizedName); +} + +/** + * 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 CAccHyperLink::get_keyBinding( + /* [in] */ long actionIndex, + /* [in] */ long nMaxBinding, + /* [length_is][length_is][size_is][size_is][out] */ BSTR __RPC_FAR *__RPC_FAR *keyBinding, + /* [retval][out] */ long __RPC_FAR *nBinding) +{ + + return CAccActionBase::get_keyBinding(actionIndex, nMaxBinding, keyBinding, nBinding); +} + +/** + * get an object + * @param + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::get_anchor(/* [in] */ long index, + /* [retval][out] */ VARIANT __RPC_FAR *anchor) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(anchor == NULL) + { + return E_INVALIDARG; + } + // #CHECK XInterface# + if(!pRXLink.is()) + { + return E_FAIL; + } + // Get Any type value via pRXLink. + ::com::sun::star::uno::Any anyVal = GetXInterface()->getAccessibleActionAnchor(index); + // Convert Any to VARIANT. + CMAccessible::ConvertAnyToVariant(anyVal, anchor); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * get an object + * @param + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::get_anchorTarget(/* [in] */ long index, + /* [retval][out] */ VARIANT __RPC_FAR *anchorTarget) +{ + + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(anchorTarget == NULL) + { + return E_INVALIDARG; + } + // #CHECK XInterface# + if(!pRXLink.is()) + { + return E_FAIL; + } + // Get Any type value via pRXLink. + ::com::sun::star::uno::Any anyVal = GetXInterface()->getAccessibleActionObject(index); + // Convert Any to VARIANT. + CMAccessible::ConvertAnyToVariant(anyVal, anchorTarget); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + + +/** + * Get start index. + * @param index Variant to get start index. + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::get_startIndex(/* [retval][out] */ long __RPC_FAR *index) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(index == NULL) + { + return E_INVALIDARG; + } + *index = GetXInterface()->getStartIndex(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get start index. + * @param index Variant to get end index. + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::get_endIndex(/* [retval][out] */ long __RPC_FAR *index) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(index == NULL) + { + return E_INVALIDARG; + } + // #CHECK XInterface# + if(!pRXLink.is()) + { + return E_FAIL; + } + *index = GetXInterface()->getEndIndex(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Judge if the hyperlink is valid. + * @param valid Variant to get validity. + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::get_valid(/* [retval][out] */ boolean __RPC_FAR *valid) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(valid == NULL) + { + return E_INVALIDARG; + } + // #CHECK XInterface# + if(!pRXLink.is()) + { + return E_FAIL; + } + *valid = GetXInterface()->isValid(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Put UNO interface. + * @param pXInterface XAccessibleContext interface. + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::put_XInterface(long pXInterface) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + CAccActionBase::put_XInterface(pXInterface); + //special query. + if(pUNOInterface != NULL) + { + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + { + return E_FAIL; + } + Reference<XAccessibleHyperlink> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + { + pRXLink = NULL; + } + else + pRXLink = pRXI.get(); + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Put UNO interface. + * @param pXSubInterface XAccessibleHyperlink interface. + * @return Result. +*/ +STDMETHODIMP CAccHyperLink::put_XSubInterface(long pXSubInterface) +{ + + CHECK_ENABLE_INF + + pRXLink = (XAccessibleHyperlink*)pXSubInterface; + pRXAct = (XAccessibleAction*)pXSubInterface; + + return S_OK; +} diff --git a/winaccessibility/source/UAccCOM/AccHyperLink.h b/winaccessibility/source/UAccCOM/AccHyperLink.h new file mode 100644 index 000000000000..56415c225ca3 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccHyperLink.h @@ -0,0 +1,140 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCHYPERLINK_H__59DA79A5_A895_43DB_9495_2B2049CF5C65__INCLUDED_) +#define AFX_ACCHYPERLINK_H__59DA79A5_A895_43DB_9495_2B2049CF5C65__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" // main symbols + + +#include <com/sun/star/accessibility/XAccessibleHyperlink.hpp> +#include "AccActionBase.h" +#include "UNOXWrapper.h" + +/** + * CAccHyperLink implements IAccessibleHyperlink interface. + */ +class ATL_NO_VTABLE CAccHyperLink : + public CComObjectRoot, + public CComCoClass<CAccHyperLink,&CLSID_AccHyperLink>, + public IAccessibleHyperlink, + public CAccActionBase +{ +public: + CAccHyperLink() + { + } + ~CAccHyperLink() + { + } + + BEGIN_COM_MAP(CAccHyperLink) + COM_INTERFACE_ENTRY(IAccessibleAction) + COM_INTERFACE_ENTRY(IAccessibleHyperlink) + COM_INTERFACE_ENTRY(IUNOXWrapper) + END_COM_MAP() + + DECLARE_REGISTRY_RESOURCEID(IDR_AccHyperLink) + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccHyperLink*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + // IAccessibleHyperlink +public: + // IAccessibleAction + + // Returns the number of action. + STDMETHOD(nActions)(/*[out,retval]*/long* nActions); + + // Performs specified action on the object. + STDMETHOD(doAction)(/* [in] */ long actionIndex); + + // get the action name + STDMETHOD(get_name)( long actionIndex, BSTR __RPC_FAR *name); + + // get the localized action name + STDMETHOD(get_localizedName)( long actionIndex, BSTR __RPC_FAR *localizedName); + + // Gets description of specified action. + STDMETHOD(get_description)(long actionIndex,BSTR __RPC_FAR *description); + + // Returns key binding object (if any) associated with specified action + // key binding is string. + // e.g. "alt+d" (like IAccessible::get_accKeyboardShortcut). + STDMETHOD(get_keyBinding)( + /* [in] */ long actionIndex, + /* [in] */ long nMaxBinding, + /* [length_is][length_is][size_is][size_is][out] */ BSTR __RPC_FAR *__RPC_FAR *keyBinding, + /* [retval][out] */ long __RPC_FAR *nBinding); + + // IAccessibleHyperlink + + // get an object, e.g. BSTR or image object, that is overloaded with link behavior + STDMETHOD(get_anchor)(/* [in] */ long index, + /* [retval][out] */ VARIANT __RPC_FAR *anchor); + + // get an object representing the target of the link, usually a BSTR of the URI + STDMETHOD(get_anchorTarget)(/* [in] */ long index, + /* [retval][out] */ VARIANT __RPC_FAR *anchorTarget); + + // Returns the index at which the textual representation of the + // hyperlink (group) starts. + STDMETHOD(get_startIndex)(/* [retval][out] */ long __RPC_FAR *index); + + // Returns the index at which the textual rerpesentation of the + // hyperlink (group) ends. + STDMETHOD(get_endIndex)(/* [retval][out] */ long __RPC_FAR *index); + + // Returns whether the document referenced by this links is still valid. + STDMETHOD(get_valid)(/* [retval][out] */ boolean __RPC_FAR *valid); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XSubInterface)(long pXSubInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleHyperlink> pRXLink; + + inline com::sun::star::accessibility::XAccessibleHyperlink* GetXInterface() + { + return pRXLink.get(); + } + +}; + +#endif // !defined(AFX_ACCHYPERLINK_H__59DA79A5_A895_43DB_9495_2B2049CF5C65__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccHyperLink.rgs b/winaccessibility/source/UAccCOM/AccHyperLink.rgs new file mode 100644 index 000000000000..ceb622ee0e95 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccHyperLink.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccHyperLink.1 = s 'AccHyperLink Class' + { + CLSID = s '{519A64CD-F6A6-4793-BE50-4E36C4C593EF}' + } + UAccCOM.AccHyperLink = s 'AccHyperLink Class' + { + CLSID = s '{519A64CD-F6A6-4793-BE50-4E36C4C593EF}' + } + NoRemove CLSID + { + ForceRemove {519A64CD-F6A6-4793-BE50-4E36C4C593EF} = s 'AccHyperLink Class' + { + ProgID = s 'UAccCOM.AccHyperLink.1' + VersionIndependentProgID = s 'UAccCOM.AccHyperLink' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccHypertext.cxx b/winaccessibility/source/UAccCOM/AccHypertext.cxx new file mode 100644 index 000000000000..5e0e40d82d2c --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccHypertext.cxx @@ -0,0 +1,409 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccHypertext.h" + +#include "act.hxx" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +///////////////////////////////////////////////////////////////////////////// +// +/** + * Get special selection. + * @param startOffset Start selection offset. + * @param endOffset End selection offset. + * @param success Variant to accept the result of if the method call is successful. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::addSelection(long startOffset, long endOffset) +{ + + return CAccTextBase::get_addSelection(startOffset, endOffset); +} + + +/** + * Get special attributes. + * @param offset Offset. + * @param startOffset Variant to accept start offset. + * @param endOffset Variant to accept end offset. + * @param textAttributes Variant to accept attributes. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_attributes(long offset, long * startOffset, long * endOffset, BSTR * textAttributes) +{ + + return CAccTextBase::get_attributes(offset, startOffset, endOffset, textAttributes); +} + +/** + * Get caret position. + * @param offset Variant to accept caret offset. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_caretOffset(long * offset) +{ + + return CAccTextBase::get_caretOffset(offset); +} + +/** + * Get character count. + * @param nCharacters Variant to accept character count. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_characterCount(long * nCharacters) +{ + + return CAccTextBase::get_characterCount(nCharacters); +} + +/** + * Get character extents. + * @param offset Offset. + * @param x Variant to accpet x position. + * @param y Variant to accpet y position. + * @param width Variant to accpet width. + * @param Height Variant to accpet height. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_characterExtents(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height) +{ + + return CAccTextBase::get_characterExtents(offset, coordType, x, y, width, height); +} + +/** + * Get slections count. + * @param nSelections Variant to accpet slections count. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_nSelections(long * nSelections) +{ + + return CAccTextBase::get_nSelections(nSelections); +} + +/** + * Get offset of some special point. + * @param x X position of one point. + * @param x Y position of one point. + * @param coordType Type. + * @param offset Variant to accept offset. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_offsetAtPoint(long x, long y, IA2CoordinateType coordType, long * offset) +{ + return CAccTextBase::get_offsetAtPoint(x, y, coordType, offset); +} + +/** + * Get selection range. + * @param selection selection count. + * @param startOffset Variant to accept the start offset of special selection. + * @param endOffset Variant to accept the end offset of special selection. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_selection(long selection, long * startOffset, long * endOffset) +{ + + return CAccTextBase::get_selection(selection, startOffset, endOffset); +} + +/** + * Get special text. + * @param startOffset Start position of special range. + * @param endOffset End position of special range. + * @param text Variant to accept the text of special range. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_text(long startOffset, long endOffset, BSTR * text) +{ + + return CAccTextBase::get_text(startOffset, endOffset, text); +} + +/** + * Get special text before some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_textBeforeOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + return CAccTextBase::get_textBeforeOffset(offset, boundaryType, + startOffset, endOffset, text); +} + +/** + * Get special text after some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_textAfterOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + return CAccTextBase::get_textAfterOffset(offset, boundaryType, + startOffset, endOffset, text); +} + +/** + * Get special text at some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_textAtOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + return CAccTextBase::get_textAtOffset(offset, boundaryType, + startOffset, endOffset, text); +} + +/** + * Remove selection. + * @param selectionIndex Special selection index + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::removeSelection(long selectionIndex) +{ + + return CAccTextBase::removeSelection(selectionIndex); +} + +/** + * Set caret position. + * @param offset Special position. + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::setCaretOffset(long offset) +{ + + return CAccTextBase::setCaretOffset(offset); +} + +/** + * Set special selection. + * @param selectionIndex Special selection index. + * @param startOffset start position. + * @param endOffset end position. + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::setSelection(long selectionIndex, long startOffset, long endOffset) +{ + + return CAccTextBase::setSelection(selectionIndex, startOffset, + endOffset); +} + +/** + * Get characters count. + * @param nCharacters Variant to accept the characters count. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_nCharacters(long * nCharacters) +{ + + return CAccTextBase::get_nCharacters(nCharacters); +} + +STDMETHODIMP CAccHypertext::get_newText( IA2TextSegment *newText) +{ + return CAccTextBase::get_newText(newText); +} + +STDMETHODIMP CAccHypertext::get_oldText( IA2TextSegment *oldText) +{ + return CAccTextBase::get_oldText(oldText); +} + +/** + * Scroll to special sub-string . + * @param startIndex Start index of sub string. + * @param endIndex End index of sub string. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::scrollSubstringToPoint(long startIndex, long endIndex,enum IA2CoordinateType coordinateType, long x, long y ) +{ + + return CAccTextBase::scrollSubstringToPoint(startIndex, endIndex, coordinateType, x, y); +} +STDMETHODIMP CAccHypertext::scrollSubstringTo(long startIndex, long endIndex,enum IA2ScrollType scrollType) +{ + + return CAccTextBase::scrollSubstringTo(startIndex, endIndex,scrollType); +} + +/** + * Get hyperlink count. + * @param hyperlinkCount Variant to accpet hyperlink count. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_nHyperlinks(long *hyperlinkCount) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(hyperlinkCount == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pHyperText.is()) + { + return E_FAIL; + } + + *hyperlinkCount = pHyperText->getHyperLinkCount(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special hyperlink. + * @param index Special hyperlink index. + * @param hyperlink Variant to accept special hyperlink via index. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_hyperlink(long index,IAccessibleHyperlink **hyperlink) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(hyperlink == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pHyperText.is()) + { + return E_FAIL; + } + + Reference<XAccessibleHyperlink> pRLink = pHyperText->getHyperLink(index); + if(!pRLink.is()) + { + *hyperlink = NULL; + return E_FAIL; + } + + IAccessibleHyperlink* plink = NULL; + ActivateActContext(); + HRESULT hr = CoCreateInstance( CLSID_AccHyperLink, NULL, CLSCTX_SERVER , + IID_IAccessibleHyperlink, + (void **)&plink); + DeactivateActContext(); + if( SUCCEEDED(hr) ) + { + IUNOXWrapper* wrapper = NULL; + plink->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper); + if(wrapper) + { + wrapper->put_XSubInterface((long)pRLink.get()/*pXI*/); + wrapper->Release(); + } + *hyperlink = plink; + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Returns the index of the hyperlink that is associated with this character index. + * @param charIndex Special char index. + * @param hyperlinkIndex Variant to accept special hyperlink index. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::get_hyperlinkIndex(long charIndex, long *hyperlinkIndex) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(hyperlinkIndex == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pHyperText.is()) + { + return E_FAIL; + } + + *hyperlinkIndex = pHyperText->getHyperLinkIndex(charIndex); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Put UNO interface. + * @param pXInterface UNO interface. + * @return Result. +*/ +STDMETHODIMP CAccHypertext::put_XInterface(long pXInterface) +{ + + + ENTER_PROTECTED_BLOCK + + CAccTextBase::put_XInterface(pXInterface); + //special query. + if(pUNOInterface == NULL) + return E_FAIL; + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + { + return E_FAIL; + } + Reference<XAccessibleHypertext> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pHyperText = NULL; + else + pHyperText = pRXI.get(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} diff --git a/winaccessibility/source/UAccCOM/AccHypertext.h b/winaccessibility/source/UAccCOM/AccHypertext.h new file mode 100644 index 000000000000..5a817d20f492 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccHypertext.h @@ -0,0 +1,161 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCHYPERTEXT_H__6DC133B6_03DB_42C6_A9B7_27AF4FDA00CA__INCLUDED_) +#define AFX_ACCHYPERTEXT_H__6DC133B6_03DB_42C6_A9B7_27AF4FDA00CA__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" // main symbols + + +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleHypertext.hpp> +#include "AccTextBase.h" + +/** + * CAccHypertext implements IAccessibleHypertext interface. + */ +class ATL_NO_VTABLE CAccHypertext : + public CComObjectRoot, + public CComCoClass<CAccHypertext,&CLSID_AccHypertext>, + public IAccessibleHypertext, + public CAccTextBase +{ +public: + CAccHypertext() + { + } + ~CAccHypertext() + { + } + + BEGIN_COM_MAP(CAccHypertext) + COM_INTERFACE_ENTRY(IAccessibleText) + COM_INTERFACE_ENTRY(IAccessibleHypertext) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccHypertext*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_AccHypertext) + + // IAccessibleHypertext +public: + // IAccessibleText + + // Adds a text selection. + STDMETHOD(addSelection)(long startOffset, long endOffset);//, unsigned char * success) + + // Gets text attributes. + STDMETHOD(get_attributes)(long offset, long * startOffset, long * endOffset, BSTR * textAttributes); + + // Gets caret offset. + STDMETHOD(get_caretOffset)(long * offset); + + // Gets total number of characters. + STDMETHOD(get_characterCount)(long * nCharacters); + + // Gets bounding rect containing the glyph(s) representing the character + // at the specified text offset + STDMETHOD(get_characterExtents)(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height); + + // Gets number of active non-contiguous selections. + STDMETHOD(get_nSelections)(long * nSelections); + + // Gets bounding rect for the glyph at a certain point. + STDMETHOD(get_offsetAtPoint)(long x, long y, IA2CoordinateType coordType, long * offset); + + // Gets character offsets of N-th active text selection. + STDMETHOD(get_selection)(long selection, long * startOffset, long * endOffset); + + // Gets a range of text by offset NOTE: returned string may be longer + // than endOffset-startOffset bytes if text contains multi-byte characters. + STDMETHOD(get_text)(long startOffset, long endOffset, BSTR * text); + + // Gets a specified amount of text that ends before a specified offset. + STDMETHOD(get_textBeforeOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Gets a specified amount of text that spans the specified offset. + STDMETHOD(get_textAfterOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Gets a specified amount of text that starts after a specified offset. + STDMETHOD(get_textAtOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Unselects a range of text. + STDMETHOD(removeSelection)(long selectionIndex); + + // Moves text caret. + STDMETHOD(setCaretOffset)(long offset); + + // Changes the bounds of an existing selection. + STDMETHOD(setSelection)(long selectionIndex, long startOffset, long endOffset); + + // Gets total number of characters. + // NOTE: this may be different than the total number of bytes required + // to store the text, if the text contains multi-byte characters. + STDMETHOD(get_nCharacters)(long * nCharacters); + + // Makes specific part of string visible on screen. + STDMETHOD(scrollSubstringTo)(long startIndex, long endIndex,enum IA2ScrollType scrollType); + + STDMETHOD(scrollSubstringToPoint)(long startIndex, long endIndex,enum IA2CoordinateType coordinateType, long x, long y ); + + STDMETHOD(get_newText)( IA2TextSegment *newText); + + STDMETHOD(get_oldText)( IA2TextSegment *oldText); + + //IAccessibleHypertext + + // Gets the number of hyperlink. + STDMETHOD(get_nHyperlinks)(long *hyperlinkCount); + + // Gets the hyperlink object via specified index. + STDMETHOD(get_hyperlink)(long index,IAccessibleHyperlink **hyperlink); + + // Returns the index of the hyperlink that is associated with this + // character index. + STDMETHOD(get_hyperlinkIndex)(long charIndex, long *hyperlinkIndex); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleHypertext> pHyperText; + +}; + +#endif // !defined(AFX_ACCHYPERTEXT_H__6DC133B6_03DB_42C6_A9B7_27AF4FDA00CA__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccHypertext.rgs b/winaccessibility/source/UAccCOM/AccHypertext.rgs new file mode 100644 index 000000000000..6baf54496e6a --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccHypertext.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccHypertext.1 = s 'AccHypertext Class' + { + CLSID = s '{CC55D71B-1828-4EE0-89E2-C3749CF9C9AB}' + } + UAccCOM.AccHypertext = s 'AccHypertext Class' + { + CLSID = s '{CC55D71B-1828-4EE0-89E2-C3749CF9C9AB}' + } + NoRemove CLSID + { + ForceRemove {CC55D71B-1828-4EE0-89E2-C3749CF9C9AB} = s 'AccHypertext Class' + { + ProgID = s 'UAccCOM.AccHypertext.1' + VersionIndependentProgID = s 'UAccCOM.AccHypertext' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccImage.cxx b/winaccessibility/source/UAccCOM/AccImage.cxx new file mode 100644 index 000000000000..7e3ba7699443 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccImage.cxx @@ -0,0 +1,102 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccImage.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +/** + * Get description. + * @param description Variant to get description. + * @return Result. +*/ +STDMETHODIMP CAccImage::get_description(BSTR * description) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if (description == NULL) + return E_INVALIDARG; + if( !pRXImg.is() ) + return E_FAIL; + + ::rtl::OUString ouStr = GetXInterface()->getAccessibleImageDescription(); + SAFE_SYSFREESTRING(*description); + *description = SysAllocString((OLECHAR*)ouStr.getStr()); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CAccImage::get_imagePosition( + /* [in] */ enum IA2CoordinateType, + /* [out] */ long __RPC_FAR *, + /* [retval][out] */ long __RPC_FAR *) +{ + return E_NOTIMPL; +} + +STDMETHODIMP CAccImage::get_imageSize( + /* [out] */ long __RPC_FAR *, + /* [retval][out] */ long __RPC_FAR *) +{ + return E_NOTIMPL; +} + +/** + * Put UNO interface. + * @param pXInterface UNO interface. + * @return Result. +*/ +STDMETHODIMP CAccImage::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<XAccessibleImage> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pRXImg = NULL; + else + pRXImg = pRXI.get(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} diff --git a/winaccessibility/source/UAccCOM/AccImage.h b/winaccessibility/source/UAccCOM/AccImage.h new file mode 100644 index 000000000000..41921f9480fe --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccImage.h @@ -0,0 +1,101 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCIMAGE_H__D5E55275_CCD4_497F_8E77_F9B391D2F4A8__INCLUDED_) +#define AFX_ACCIMAGE_H__D5E55275_CCD4_497F_8E77_F9B391D2F4A8__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" // main symbols + + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleImage.hpp> +#include "UNOXWrapper.h" + +/** + * CAccImage implements IAccessibleImage interface. + */ +class ATL_NO_VTABLE CAccImage : + public CComObjectRoot, + public CComCoClass<CAccImage,&CLSID_AccImage>, + public IAccessibleImage, + public CUNOXWrapper +{ +public: + CAccImage() + { + } + virtual ~CAccImage() + { + } + BEGIN_COM_MAP(CAccImage) + COM_INTERFACE_ENTRY(IAccessibleImage) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccImage*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_AccImage) + + // IAccessibleImage +public: + // IAccessibleImage + + // Gets the description of the image. + STDMETHOD(get_description)(BSTR * description); + + STDMETHOD(get_imagePosition)( enum IA2CoordinateType coordinateType, + long __RPC_FAR *x, + long __RPC_FAR *y); + + STDMETHOD(get_imageSize)( + long __RPC_FAR *height, + long __RPC_FAR *width); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleImage> pRXImg; + + inline com::sun::star::accessibility::XAccessibleImage* GetXInterface() + { + return pRXImg.get(); + } +}; + +#endif // !defined(AFX_ACCIMAGE_H__D5E55275_CCD4_497F_8E77_F9B391D2F4A8__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccImage.rgs b/winaccessibility/source/UAccCOM/AccImage.rgs new file mode 100644 index 000000000000..9be96fd3e777 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccImage.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccImage.1 = s 'AccImage Class' + { + CLSID = s '{73A45800-7A62-432C-A1A6-BF8852994331}' + } + UAccCOM.AccImage = s 'AccImage Class' + { + CLSID = s '{73A45800-7A62-432C-A1A6-BF8852994331}' + } + NoRemove CLSID + { + ForceRemove {73A45800-7A62-432C-A1A6-BF8852994331} = s 'AccImage Class' + { + ProgID = s 'UAccCOM.AccImage.1' + VersionIndependentProgID = s 'UAccCOM.AccImage' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccKeyBinding.rgs b/winaccessibility/source/UAccCOM/AccKeyBinding.rgs new file mode 100644 index 000000000000..6967bf2b6458 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccKeyBinding.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccKeyBinding.1 = s 'AccKeyBinding Class' + { + CLSID = s '{98AFE6FB-D748-4313-B4D6-E7B273B6255D}' + } + UAccCOM.AccKeyBinding = s 'AccKeyBinding Class' + { + CLSID = s '{98AFE6FB-D748-4313-B4D6-E7B273B6255D}' + } + NoRemove CLSID + { + ForceRemove {98AFE6FB-D748-4313-B4D6-E7B273B6255D} = s 'AccKeyBinding Class' + { + ProgID = s 'UAccCOM.AccKeyBinding.1' + VersionIndependentProgID = s 'UAccCOM.AccKeyBinding' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccRelation.cxx b/winaccessibility/source/UAccCOM/AccRelation.cxx new file mode 100644 index 000000000000..1eb261575be7 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccRelation.cxx @@ -0,0 +1,214 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccRelation.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include "MAccessible.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +/** + * Get relation type. + * @param relationType Variant to get relation type. + * @return Result. +*/ +STDMETHODIMP CAccRelation::get_relationType(BSTR * relationType) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (relationType == NULL) + return E_INVALIDARG; + + int type = relation.RelationType; + SAFE_SYSFREESTRING(*relationType); + + *relationType = getRelationTypeBSTR(type); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +// Gets what the type of localized relation is. +STDMETHODIMP CAccRelation::get_localizedRelationType(BSTR *) +{ + + + ENTER_PROTECTED_BLOCK + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get targets length. + * @param nTargets Variant to get targets length. + * @return Result. +*/ +STDMETHODIMP CAccRelation::get_nTargets(long * nTargets) +{ + + + ENTER_PROTECTED_BLOCK + + CHECK_ENABLE_INF + if (nTargets == NULL) + return E_INVALIDARG; + + Sequence< Reference< XInterface > > xTargets = relation.TargetSet; + *nTargets = xTargets.getLength(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special target. + * @param targetIndex target index. + * @param target Variant to get special target. + * @return Result. +*/ +STDMETHODIMP CAccRelation::get_target(long targetIndex, IUnknown * * target) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (target == NULL) + return E_FAIL; + + Sequence< Reference< XInterface > > xTargets = relation.TargetSet; + int nCount = xTargets.getLength(); + if( targetIndex >= nCount ) + return E_FAIL; + + Reference<XInterface> pRAcc = xTargets[targetIndex]; + IAccessible* pRet = NULL; + + BOOL isGet = CMAccessible::get_IAccessibleFromXAccessible((long)pRAcc.get(),&pRet); + if(isGet) + { + *target = /*(IAccessible2 *)*/(IUnknown*)pRet; + pRet->AddRef(); + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special targets. + * @param maxTargets Special targets count. + * @param target Variant to get special target. + * @param nTargets Variant to accept actual target length. + * @return Result. +*/ +STDMETHODIMP CAccRelation::get_targets(long, IUnknown * * target, long * nTargets) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(target == NULL) + return E_INVALIDARG; + if (nTargets == NULL) + return E_INVALIDARG; + + Sequence< Reference< XInterface > > xTargets = relation.TargetSet; + int nCount = xTargets.getLength(); + + *target = (IUnknown*)::CoTaskMemAlloc(nCount*sizeof(IUnknown)); + + // #CHECK Memory Allocation# + if(*target == NULL) + { + return E_FAIL; + } + + for(int i=0; i<nCount ; i++) + { + IUnknown* pAcc = NULL; + HRESULT hr = get_target(i,&pAcc); + if(SUCCEEDED(hr)) + target[i] = pAcc; + } + + *nTargets = nCount; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Put UNO interface. + * @param pXSubInterface AccessibleRelation pointer. + * @return Result. +*/ +STDMETHODIMP CAccRelation::put_XSubInterface(long pXSubInterface) +{ + + relation = *((AccessibleRelation*)pXSubInterface); + return S_OK; +} + +/** + * Get relation type string by type. + * @param type Relation type. + * @return relation type string. +*/ +BSTR CAccRelation::getRelationTypeBSTR(int type) +{ + static struct TYPE_BSTR_MAP + { + LPCTSTR string; + int type; + } + map[] = + { + {_T("INVALID") , 0}, + {IA2_RELATION_FLOWS_FROM , 1}, + {IA2_RELATION_FLOWS_TO , 2}, + {IA2_RELATION_CONTROLLED_BY , 3}, + {IA2_RELATION_CONTROLLER_FOR, 4}, + {IA2_RELATION_LABEL_FOR , 5}, + {IA2_RELATION_LABELED_BY , 6}, + {IA2_RELATION_MEMBER_OF , 7}, + {IA2_RELATION_SUBWINDOW_OF , 8}, + {IA2_RELATION_NODE_CHILD_OF, 9}, + {IA2_RELATION_DESCRIBED_BY , 10}, + }; + + USES_CONVERSION; + + return (type >= 0 && type <= 10) ? T2BSTR(map[type].string) : _T(""); +} diff --git a/winaccessibility/source/UAccCOM/AccRelation.h b/winaccessibility/source/UAccCOM/AccRelation.h new file mode 100644 index 000000000000..a7903f7dc571 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccRelation.h @@ -0,0 +1,88 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __ACCRELATION_H_ +#define __ACCRELATION_H_ + +#include "resource.h" // main symbols + + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleRelationSet.hpp> +#include "UNOXWrapper.h" + +/** + * CAccRelation implements IAccessibleRelation interface. + */ +class ATL_NO_VTABLE CAccRelation : + public CComObjectRoot, + public CComCoClass<CAccRelation, &CLSID_AccRelation>, + public IAccessibleRelation, + public CUNOXWrapper +{ +public: + CAccRelation() + { + } + virtual ~CAccRelation() + { + } + + DECLARE_REGISTRY_RESOURCEID(IDR_ACCRELATION) + + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CAccRelation) + COM_INTERFACE_ENTRY(IAccessibleRelation) + COM_INTERFACE_ENTRY(IUNOXWrapper) + END_COM_MAP() + + // IAccessibleRelation +public: + // IAccessibleRelation + + // Gets what the type of relation is. + STDMETHOD(get_relationType)(BSTR * relationType); + + // Gets what the type of localized relation is. + STDMETHOD(get_localizedRelationType)(BSTR * relationType); + + // Gets how many targets this relation have. + STDMETHOD(get_nTargets)(long * nTargets); + + // Gets one accessible relation target. + STDMETHOD(get_target)(long targetIndex, IUnknown * * target); + + // Gets multiple accessible relation targets. + STDMETHOD(get_targets)(long maxTargets, IUnknown * * target, long * nTargets); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XSubInterface)(long pXSubInterface); + + //static OLECHAR* getRelationTypeOLECHAR(int type); + static BSTR getRelationTypeBSTR(int type); + +private: + + com::sun::star::accessibility::AccessibleRelation relation; +}; + +#endif //__ACCRELATION_H_ diff --git a/winaccessibility/source/UAccCOM/AccRelation.rgs b/winaccessibility/source/UAccCOM/AccRelation.rgs new file mode 100644 index 000000000000..3a7d3d2c6ed1 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccRelation.rgs @@ -0,0 +1,25 @@ +HKCR +{ + UAccCOM.AccRelation.1 = s 'AccRelation Class' + { + CLSID = s '{8745CF0C-3104-4BAE-B7D0-D7B1717C006E}' + } + UAccCOM.AccRelation = s 'AccRelation Class' + { + CLSID = s '{8745CF0C-3104-4BAE-B7D0-D7B1717C006E}' + CurVer = s 'UAccCOM.AccRelation.1' + } + NoRemove CLSID + { + ForceRemove {8745CF0C-3104-4BAE-B7D0-D7B1717C006E} = s 'AccRelation Class' + { + ProgID = s 'UAccCOM.AccRelation.1' + VersionIndependentProgID = s 'UAccCOM.AccRelation' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + 'TypeLib' = s '{19ECB1B0-9376-4FF9-B580-223FC9C200B8}' + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccSelection.rgs b/winaccessibility/source/UAccCOM/AccSelection.rgs new file mode 100644 index 000000000000..484099086c5d --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccSelection.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccSelection.1 = s 'AccSelection Class' + { + CLSID = s '{9B83B8C3-3592-4C29-8682-559E37368E95}' + } + UAccCOM.AccSelection = s 'AccSelection Class' + { + CLSID = s '{9B83B8C3-3592-4C29-8682-559E37368E95}' + } + NoRemove CLSID + { + ForceRemove {9B83B8C3-3592-4C29-8682-559E37368E95} = s 'AccSelection Class' + { + ProgID = s 'UAccCOM.AccSelection.1' + VersionIndependentProgID = s 'UAccCOM.AccSelection' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccTable.cxx b/winaccessibility/source/UAccCOM/AccTable.cxx new file mode 100644 index 000000000000..4ad5e22c782e --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccTable.cxx @@ -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 + +} diff --git a/winaccessibility/source/UAccCOM/AccTable.h b/winaccessibility/source/UAccCOM/AccTable.h new file mode 100644 index 000000000000..245c54720550 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccTable.h @@ -0,0 +1,175 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __ACCTABLE_H_ +#define __ACCTABLE_H_ + +#include "resource.h" // main symbols + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleTable.hpp> +#include "UNOXWrapper.h" + +/** + * CAccTable implements IAccessibleTable interface. + */ +class ATL_NO_VTABLE CAccTable : + public CComObjectRoot, + public CComCoClass<CAccTable, &CLSID_AccTable>, + public IAccessibleTable, + public CUNOXWrapper + +{ +public: + CAccTable() + { + } + virtual ~CAccTable() + { + } + + BEGIN_COM_MAP(CAccTable) + COM_INTERFACE_ENTRY(IAccessibleTable) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccTable*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_ACCTABLE) + + // IAccessibleTable +public: + // IAccessibleTable + + // Gets accessible table cell. + STDMETHOD(get_accessibleAt)(long row, long column, IUnknown * * accessible); + + // Gets accessible table caption. + STDMETHOD(get_caption)(IUnknown * * accessible); + + // Gets accessible column description (as string). + STDMETHOD(get_columnDescription)(long column, BSTR * description); + + // Gets number of columns spanned by table cell. + STDMETHOD(get_columnExtentAt)(long row, long column, long * nColumnsSpanned); + + // Gets accessible column header. + STDMETHOD(get_columnHeader)(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingRowIndex); + + // Gets total number of columns in table. + STDMETHOD(get_nColumns)(long * columnCount); + + // Gets total number of rows in table. + STDMETHOD(get_nRows)(long * rowCount); + + // Gets total number of selected columns. + STDMETHOD(get_nSelectedColumns)(long * columnCount); + + // Gets total number of selected rows. + STDMETHOD(get_nSelectedRows)(long * rowCount); + + // Gets accessible row description (as string). + STDMETHOD(get_rowDescription)(long row, BSTR * description); + + // Gets number of rows spanned by a table cell. + STDMETHOD(get_rowExtentAt)(long row, long column, long * nRowsSpanned); + + // Gets accessible row header. + STDMETHOD(get_rowHeader)(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingColumnIndex); + + // Gets list of row indexes currently selected (0-based). + STDMETHOD(get_selectedRows)(long maxRows, long **rows, long * nRows); + + // Gets list of column indexes currently selected (0-based). + STDMETHOD(get_selectedColumns)(long maxColumns, long **columns, long * numColumns); + + // Gets accessible table summary. + STDMETHOD(get_summary)(IUnknown * * accessible); + + // Determines if table column is selected. + STDMETHOD(get_isColumnSelected)(long column, unsigned char * isSelected); + + // Determines if table row is selected. + STDMETHOD(get_isRowSelected)(long row, unsigned char * isSelected); + + // Determines if table cell is selected. + STDMETHOD(get_isSelected)(long row, long column, unsigned char * isSelected); + + // Selects a row and unselect all previously selected rows. + STDMETHOD(selectRow)(long row ); + + + // Selects a column and unselect all previously selected columns. + + STDMETHOD(selectColumn)(long column); + + // Unselects one row, leaving other selected rows selected (if any). + STDMETHOD(unselectRow)(long row); + + // Unselects one column, leaving other selected columns selected (if any). + STDMETHOD(unselectColumn)(long column); + + //get Column index + STDMETHOD(get_columnIndex)(long childIndex, long * columnIndex); + + STDMETHOD(get_rowIndex)(long childIndex, long * rowIndex); + + STDMETHOD(get_childIndex)(long rowIndex,long columnIndex, long * childIndex); + + STDMETHOD(get_nSelectedChildren)(long *childCount); + + STDMETHOD(get_selectedChildren)(long maxChildren, long **children, long *nChildren); + + STDMETHOD(get_rowColumnExtentsAtIndex)( long index, + long *row, + long *column, + long *rowExtents, + long *columnExtents, + boolean *isSelected) ; + + STDMETHOD(get_modelChange)(IA2TableModelChange *modelChange); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleTable> pRXTable; + + inline com::sun::star::accessibility::XAccessibleTable* GetXInterface() + { + return pRXTable.get(); + } +}; + +#endif //__ACCTABLE_H_ diff --git a/winaccessibility/source/UAccCOM/AccTable.rgs b/winaccessibility/source/UAccCOM/AccTable.rgs new file mode 100644 index 000000000000..7117fe698934 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccTable.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccTable.1 = s 'AccTable Class' + { + CLSID = s '{92BAA62D-535A-4EAB-9ABB-BFA60B7A6DB6}' + } + UAccCOM.AccTable = s 'AccTable Class' + { + CLSID = s '{92BAA62D-535A-4EAB-9ABB-BFA60B7A6DB6}' + } + NoRemove CLSID + { + ForceRemove {92BAA62D-535A-4EAB-9ABB-BFA60B7A6DB6} = s 'AccTable Class' + { + ProgID = s 'UAccCOM.AccTable.1' + VersionIndependentProgID = s 'UAccCOM.AccTable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccText.cxx b/winaccessibility/source/UAccCOM/AccText.cxx new file mode 100644 index 000000000000..ab0702993615 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccText.cxx @@ -0,0 +1,282 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccText.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +/** + * Get special selection. + * @param startOffset Start selection offset. + * @param endOffset End selection offset. + * @param success Variant to accept the result of if the method call is successful. + * @return Result. +*/ +STDMETHODIMP CAccText::addSelection(long startOffset, long endOffset)//, unsigned char * success) +{ + + return CAccTextBase::get_addSelection(startOffset, endOffset);//, success); +} + +/** + * Get special attributes. + * @param offset Offset. + * @param startOffset Variant to accept start offset. + * @param endOffset Variant to accept end offset. + * @param textAttributes Variant to accept attributes. + * @return Result. +*/ +STDMETHODIMP CAccText::get_attributes(long offset, long * startOffset, long * endOffset, BSTR * textAttributes) +{ + + return CAccTextBase::get_attributes(offset, startOffset, endOffset, textAttributes); +} + +/** + * Get caret position. + * @param offset Variant to accept caret offset. + * @return Result. +*/ +STDMETHODIMP CAccText::get_caretOffset(long * offset) +{ + + return CAccTextBase::get_caretOffset(offset); +} + +/** + * Get character count. + * @param nCharacters Variant to accept character count. + * @return Result. +*/ +STDMETHODIMP CAccText::get_characterCount(long * nCharacters) +{ + + return CAccTextBase::get_characterCount(nCharacters); +} + +/** + * Get character extents. + * @param offset Offset. + * @param x Variant to accpet x position. + * @param y Variant to accpet y position. + * @param width Variant to accpet width. + * @param Height Variant to accpet height. + * @return Result. +*/ +STDMETHODIMP CAccText::get_characterExtents(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height) +{ + + return CAccTextBase::get_characterExtents(offset, coordType, x, y, width, height); +} + +/** + * Get slections count. + * @param nSelections Variant to accpet slections count. + * @return Result. +*/ +STDMETHODIMP CAccText::get_nSelections(long * nSelections) +{ + + return CAccTextBase::get_nSelections(nSelections); +} + +/** + * Get offset of some special point. + * @param x X position of one point. + * @param x Y position of one point. + * @param coordType Type. + * @param offset Variant to accept offset. + * @return Result. +*/ + +STDMETHODIMP CAccText::get_offsetAtPoint(long x, long y, IA2CoordinateType coordType, long * offset) +{ + + return CAccTextBase::get_offsetAtPoint(x, y, coordType, offset); +} + +/** + * Get selection range. + * @param selection selection count. + * @param startOffset Variant to accept the start offset of special selection. + * @param endOffset Variant to accept the end offset of special selection. + * @return Result. +*/ +STDMETHODIMP CAccText::get_selection(long selection, long * startOffset, long * endOffset) +{ + + return CAccTextBase::get_selection(selection, startOffset, endOffset); +} + +/** + * Get special text. + * @param startOffset Start position of special range. + * @param endOffset End position of special range. + * @param text Variant to accept the text of special range. + * @return Result. +*/ +STDMETHODIMP CAccText::get_text(long startOffset, long endOffset, BSTR * text) +{ + + return CAccTextBase::get_text(startOffset, endOffset, text); +} + +/** + * Get special text before some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccText::get_textBeforeOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + return CAccTextBase::get_textBeforeOffset(offset, boundaryType, + startOffset, endOffset, text); +} + +/** + * Get special text after some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccText::get_textAfterOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + return CAccTextBase::get_textAfterOffset(offset, boundaryType, + startOffset, endOffset, text); +} + +/** + * Get special text at some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccText::get_textAtOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + return CAccTextBase::get_textAtOffset(offset, boundaryType, + startOffset, endOffset, text); +} + +/** + * Remove selection. + * @param selectionIndex Special selection index + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccText::removeSelection(long selectionIndex)//, unsigned char * success) +{ + + return CAccTextBase::removeSelection(selectionIndex);//, success); +} + +/** + * Set caret position. + * @param offset Special position. + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccText::setCaretOffset(long offset) +{ + + return CAccTextBase::setCaretOffset(offset); +} + +/** + * Set special selection. + * @param selectionIndex Special selection index. + * @param startOffset start position. + * @param endOffset end position. + * @param success Variant to accept the memthod called result. + * @return Result. +*/ + +STDMETHODIMP CAccText::setSelection(long selectionIndex, long startOffset, long endOffset) +{ + + return CAccTextBase::setSelection(selectionIndex, startOffset, + endOffset); +} + +/** + * Get characters count. + * @param nCharacters Variant to accept the characters count. + * @return Result. +*/ +STDMETHODIMP CAccText::get_nCharacters(long * nCharacters) +{ + + return CAccTextBase::get_nCharacters(nCharacters); +} + +STDMETHODIMP CAccText::get_newText( IA2TextSegment *newText) +{ + return CAccTextBase::get_newText(newText); +} + +STDMETHODIMP CAccText::get_oldText( IA2TextSegment *oldText) +{ + return CAccTextBase::get_oldText(oldText); +} + +/** + * Scroll to special sub-string . + * @param startIndex Start index of sub string. + * @param endIndex End index of sub string. + * @return Result. +*/ +STDMETHODIMP CAccText::scrollSubstringToPoint(long startIndex, long endIndex,enum IA2CoordinateType coordinateType, long x, long y ) +{ + + return CAccTextBase::scrollSubstringToPoint(startIndex, endIndex, coordinateType, x, y); +} + +STDMETHODIMP CAccText::scrollSubstringTo(long startIndex, long endIndex,enum IA2ScrollType scrollType) +{ + + return CAccTextBase::scrollSubstringTo(startIndex, endIndex,scrollType); +} + +/** + * Put UNO interface. + * @param pXInterface UNO interface. + * @return Result. +*/ +STDMETHODIMP CAccText::put_XInterface(long pXInterface) +{ + + return CAccTextBase::put_XInterface(pXInterface); +} + diff --git a/winaccessibility/source/UAccCOM/AccText.h b/winaccessibility/source/UAccCOM/AccText.h new file mode 100644 index 000000000000..7eb1c33f5086 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccText.h @@ -0,0 +1,140 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCTEXT_H__F06C5496_9959_4C7C_873E_A8D50CFB290D__INCLUDED_) +#define AFX_ACCTEXT_H__F06C5496_9959_4C7C_873E_A8D50CFB290D__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" // main symbols + +#include "AccTextBase.h" + +/** + * CAccText implements IAccessibleText interface. + */ +class ATL_NO_VTABLE CAccText : + public CComObjectRoot, + public CComCoClass<CAccText,&CLSID_AccText>, + public IAccessibleText, + public CAccTextBase +{ +public: + CAccText() + { + } + ~CAccText() + { + } + + BEGIN_COM_MAP(CAccText) + COM_INTERFACE_ENTRY(IAccessibleText) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccText*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_AccText) + + // IAccessibleText +public: + // IAccessibleText + + // Adds a text selection. + STDMETHOD(addSelection)(long startOffset, long endOffset);//, unsigned char * success); + + // Gets text attributes. + STDMETHOD(get_attributes)(long offset, long * startOffset, long * endOffset, BSTR * textAttributes); + + // Gets caret offset. + STDMETHOD(get_caretOffset)(long * offset); + + // Gets total number of characters. + STDMETHOD(get_characterCount)(long * nCharacters); + + // Gets bounding rect containing the glyph(s) representing the character + // at the specified text offset + STDMETHOD(get_characterExtents)(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height); + + // Gets number of active non-contiguous selections. + STDMETHOD(get_nSelections)(long * nSelections); + + // Gets bounding rect for the glyph at a certain point. + STDMETHOD(get_offsetAtPoint)(long x, long y, IA2CoordinateType coordType, long * offset); + + // Gets character offsets of N-th active text selection. + STDMETHOD(get_selection)(long selection, long * startOffset, long * endOffset); + + // Gets a range of text by offset NOTE: returned string may be longer + // than endOffset-startOffset bytes if text contains multi-byte characters. + STDMETHOD(get_text)(long startOffset, long endOffset, BSTR * text); + + // Gets a specified amount of text that ends before a specified offset. + STDMETHOD(get_textBeforeOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Gets a specified amount of text that spans the specified offset. + STDMETHOD(get_textAfterOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Gets a specified amount of text that starts after a specified offset. + STDMETHOD(get_textAtOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Unselects a range of text. + STDMETHOD(removeSelection)(long selectionIndex);//, unsigned char * success); + + // Moves text caret. + STDMETHOD(setCaretOffset)(long offset);//, unsigned char * success); + + // Changes the bounds of an existing selection. + STDMETHOD(setSelection)(long selectionIndex, long startOffset, long endOffset);//, unsigned char * success); + + // Gets total number of characters. + // NOTE: this may be different than the total number of bytes required + // to store the text, if the text contains multi-byte characters. + STDMETHOD(get_nCharacters)(long * nCharacters); + + // Makes specific part of string visible on screen. + STDMETHOD(scrollSubstringTo)(long startIndex, long endIndex,enum IA2ScrollType scrollType); + STDMETHOD(scrollSubstringToPoint)(long startIndex, long endIndex,enum IA2CoordinateType coordinateType, long x, long y ); + + STDMETHOD(get_newText)( IA2TextSegment *newText); + + STDMETHOD(get_oldText)( IA2TextSegment *oldText); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +}; + +#endif // !defined(AFX_ACCTEXT_H__F06C5496_9959_4C7C_873E_A8D50CFB290D__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccText.rgs b/winaccessibility/source/UAccCOM/AccText.rgs new file mode 100644 index 000000000000..6cb3ebdcfa0a --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccText.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccText.1 = s 'AccText Class' + { + CLSID = s '{6D8AB08B-CCE9-471E-8A41-35773D5263F5}' + } + UAccCOM.AccText = s 'AccText Class' + { + CLSID = s '{6D8AB08B-CCE9-471E-8A41-35773D5263F5}' + } + NoRemove CLSID + { + ForceRemove {6D8AB08B-CCE9-471E-8A41-35773D5263F5} = s 'AccText Class' + { + ProgID = s 'UAccCOM.AccText.1' + VersionIndependentProgID = s 'UAccCOM.AccText' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccTextBase.cxx b/winaccessibility/source/UAccCOM/AccTextBase.cxx new file mode 100644 index 000000000000..6b7a38fba7aa --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccTextBase.cxx @@ -0,0 +1,995 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +////////////////////////////////////////////////////////////////////// +// AccTextBase.cpp: implementation of the CAccTextBase class. +////////////////////////////////////////////////////////////////////// +#include "stdafx.h" +#include <string> +#define WNT + +#include <com/sun/star/accessibility/AccessibleTextType.hpp> +#include "AccTextBase.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include <com/sun/star/accessibility/XAccessibleComponent.hpp> +#include <com/sun/star/accessibility/XAccessibleTextSelection.hpp> +#include "MAccessible.h" + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; +using namespace rtl; + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +OUString ReplaceFourChar(OUString oldOUString); + +CAccTextBase::CAccTextBase() +{} + +CAccTextBase::~CAccTextBase() +{} + + +/** + * Get special selection. + * @param startOffset Start selection offset. + * @param endOffset End selection offset. + * @param success Variant to accept the result of if the method call is successful. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_addSelection(long startOffset, long endOffset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK XInterface# + if(pUNOInterface == NULL) + return E_FAIL; + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + + Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); + + if( pRExtension.is() ) + { + pRExtension->addSelection(0, startOffset, endOffset); + return S_OK; + } + else + { + GetXInterface()->setSelection(startOffset, endOffset); + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special attributes. + * @param offset Offset. + * @param startOffset Variant to accept start offset. + * @param endOffset Variant to accept end offset. + * @param textAttributes Variant to accept attributes. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_attributes(long offset, long * startOffset, long * endOffset, BSTR * textAttributes) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (startOffset == NULL || endOffset == NULL || textAttributes == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + { + return E_FAIL; + } + + if( offset < 0 || offset > GetXInterface()->getCharacterCount() ) + return E_FAIL; + + std::wstring strAttrs; + + strAttrs += L"Version:1;"; + + Sequence< ::com::sun::star::beans::PropertyValue > pValues = GetXInterface()->getCharacterAttributes(offset, Sequence< rtl::OUString >()); + int nCount = pValues.getLength(); + + short numberingLevel = 0; + OUString numberingPrefix; + Any anyNumRule; + bool bHaveNumberingPrefixAttr = false; + bool bHaveNumberingLevel = false; + bool bHaveNumberingRules = false; + for(int i =0; i<nCount; i++) + { + + ::com::sun::star::beans::PropertyValue &pValue = pValues[i]; + if(pValue.Name.compareTo(OUString::createFromAscii("NumberingLevel"))==0) + { + if (pValue.Value != Any()) + pValue.Value >>= numberingLevel; + else + numberingLevel = -1; + bHaveNumberingLevel = true; + continue; + } + if(pValue.Name.compareTo(OUString::createFromAscii("NumberingPrefix"))==0) + { + pValue.Value >>=numberingPrefix; + bHaveNumberingPrefixAttr = true; + continue; + } + if(pValue.Name.compareTo(OUString::createFromAscii("NumberingRules"))==0) + { + bHaveNumberingRules = true; + anyNumRule = pValue.Value; + continue; + } + if (bHaveNumberingLevel && bHaveNumberingRules && bHaveNumberingPrefixAttr) + { + OLECHAR numProps[512] = {0}; + strAttrs+=L";"; + numberingPrefix = ReplaceFourChar(numberingPrefix); + CMAccessible::get_OLECHAR4Numbering(anyNumRule,numberingLevel,numberingPrefix,numProps); + strAttrs += numProps; + bHaveNumberingLevel = 0; + bHaveNumberingRules = 0; + } + if( (bHaveNumberingPrefixAttr && i > 1 ) || + (!bHaveNumberingPrefixAttr && i > 0 ) ) //element 0 is NumberingPrefix, not write alone + { + strAttrs+=L";"; + } + strAttrs += pValue.Name.getStr(); + strAttrs += L":"; + + OLECHAR pTemp[2048] = {0}; + + if (pValue.Name.compareTo(OUString::createFromAscii("CharBackColor"))==0 || + pValue.Name.compareTo(OUString::createFromAscii("CharColor"))==0 || + pValue.Name.compareTo(OUString::createFromAscii("CharUnderlineColor"))==0 ) + { + unsigned long nColor; + pValue.Value >>= nColor; + OLECHAR pBuf[64]; + swprintf( pBuf, L"%08X", nColor ); + pTemp[0]=L'#'; + wcscat( pTemp, pBuf ); + + } + else + { + CMAccessible::get_OLECHARFromAny(pValue.Value,pTemp); + } + + strAttrs +=pTemp; + } + strAttrs +=L";"; + // #CHECK# + if(*textAttributes) + SysFreeString(*textAttributes); + *textAttributes = SysAllocString(strAttrs.c_str()); + + if( offset < GetXInterface()->getCharacterCount() ) + { + TextSegment textSeg = GetXInterface()->getTextAtIndex(offset, AccessibleTextType::ATTRIBUTE_RUN); + *startOffset = textSeg.SegmentStart; + *endOffset = textSeg.SegmentEnd; + } + else + { + *startOffset = offset; + *endOffset = offset; + } + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get caret position. + * @param offset Variant to accept caret offset. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_caretOffset(long * offset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (offset == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + { + *offset = 0; + return S_OK; + } + + *offset = GetXInterface()->getCaretPosition(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get character count. + * @param nCharacters Variant to accept character count. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_characterCount(long * nCharacters) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (nCharacters == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + { + *nCharacters = 0; + return S_OK; + } + + *nCharacters = GetXInterface()->getCharacterCount(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get character extents. + * @param offset Offset. + * @param x Variant to accept x position. + * @param y Variant to accept y position. + * @param width Variant to accept width. + * @param Height Variant to accept height. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_characterExtents(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (x == NULL || height == NULL || y == NULL || width == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + if(offset < 0 || offset > GetXInterface()->getCharacterCount() ) + return E_FAIL; + + com::sun::star::awt::Rectangle rectangle; + rectangle = GetXInterface()->getCharacterBounds(offset); + + //IA2Point aPoint; + com::sun::star::awt::Point aPoint; + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + { + return E_FAIL; + } + Reference<XAccessibleComponent> pRComp(pRContext,UNO_QUERY); + if( pRComp.is() ) + { + if(coordType == IA2_COORDTYPE_SCREEN_RELATIVE) + { + ::com::sun::star::awt::Point pt = pRComp->getLocationOnScreen(); + aPoint.X = pt.X; + aPoint.Y = pt.Y; + } + else if(coordType == IA2_COORDTYPE_PARENT_RELATIVE) + { + ::com::sun::star::awt::Point pt = pRComp->getLocation(); + aPoint.X = pt.X; + aPoint.Y = pt.Y; + } + } + rectangle.X = rectangle.X + aPoint.X; + rectangle.Y = rectangle.Y + aPoint.Y; + + *x = rectangle.X; + *y = rectangle.Y; + + // GetXInterface()->getCharacterBounds() have different implement in different acc component + // But we need return the width/height == 1 for every component when offset == text length. + // So we ignore the return result of GetXInterface()->getCharacterBounds() when offset == text length. + if( offset == GetXInterface()->getCharacterCount() ) + { + *width = 1; + *height = 1; + } + else + { + *width = rectangle.Width; + *height = rectangle.Height; + } + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get selections count. + * @param nSelections Variant to accept selections count. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_nSelections(long * nSelections) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (nSelections == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(pUNOInterface == NULL) + { + *nSelections = 0; + return S_OK; + } + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + + Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); + + if( pRExtension.is() ) + { + *nSelections = pRExtension->getSelectedPortionCount(); + return S_OK; + } + + long iLength = GetXInterface()->getSelectedText().getLength(); + if( iLength> 0) + { + *nSelections = 1; + return S_OK; + } + + *nSelections = 0; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get offset of some special point. + * @param x X position of one point. + * @param x Y position of one point. + * @param coordType Type. + * @param offset Variant to accept offset. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_offsetAtPoint(long x, long y, IA2CoordinateType, long * offset) +{ + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + + if (offset == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + com::sun::star::awt::Point point; + point.X = x; + point.Y = y; + *offset = GetXInterface()->getIndexAtPoint(point); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get selection range. + * @param selection selection count. + * @param startOffset Variant to accept the start offset of special selection. + * @param endOffset Variant to accept the end offset of special selection. + * @return Result. +*/ + +STDMETHODIMP CAccTextBase::get_selection(long selectionIndex, long * startOffset, long * endOffset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (startOffset == NULL || endOffset == NULL ) + return E_INVALIDARG; + // #CHECK XInterface# + if(pUNOInterface == NULL ) + return E_FAIL; + + long nSelection = 0; + get_nSelections(&nSelection); + + if(selectionIndex >= nSelection || selectionIndex < 0 ) + return E_FAIL; + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + + Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); + + if( pRExtension.is() ) + { + *startOffset = pRExtension->getSeletedPositionStart(selectionIndex); + *endOffset = pRExtension->getSeletedPositionEnd(selectionIndex); + return S_OK; + } + else if(GetXInterface()->getSelectionEnd() > -1) + { + *startOffset = GetXInterface()->getSelectionStart(); + *endOffset = GetXInterface()->getSelectionEnd(); + return S_OK; + } + + *startOffset = 0; + *endOffset = 0; + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special text. + * @param startOffset Start position of special range. + * @param endOffset End position of special range. + * @param text Variant to accept the text of special range. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_text(long startOffset, long endOffset, BSTR * text) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (text == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + if (endOffset < -1 || endOffset < startOffset ) + { + return E_FAIL; + } + + ::rtl::OUString ouStr; + if (endOffset == -1 ) + { + long nLen=0; + if(SUCCEEDED(get_characterCount(&nLen))) + { + ouStr = GetXInterface()->getTextRange( 0, nLen ); + } + } + else + { + ouStr = GetXInterface()->getTextRange( startOffset, endOffset ); + } + + SysFreeString(*text); + *text = SysAllocString((OLECHAR*)ouStr.getStr()); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special text before some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_textBeforeOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if (startOffset == NULL || endOffset == NULL || text == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + // In New UNO IAccessibleText.idl these constant values are defined as follows: + // + // const long TEXT_BOUNDARY_CHAR = -1; + // const long TEXT_BOUNDARY_TO_CURSOR_POS = -2; + // const long TEXT_BOUNDARY_START_OF_WORD = -3; + // const long TEXT_BOUNDARY_END_OF_WORD = -4; + // const long TEXT_BOUNDARY_START_OF_SENTENCE = -5; + // const long TEXT_BOUNDARY_END_OF_SENTENCE = -6; + // const long TEXT_BOUNDARY_START_OF_LINE = -7; + // const long TEXT_BOUNDARY_END_OF_LINE = -8; + // + // In UNO, the corresponding values are as follows: + // + // const short CHARACTER = 1; + // const short WORD = 2; + // const short SENTENCE = 3; + // const short PARAGRAPH = 4; + // const short LINE = 5; + // const short GLYPH = 6; + // const short ATTRIBUTE_RUN = 7; + // + + long lUnoBoundaryType; + + switch(boundaryType) + { + case IA2_TEXT_BOUNDARY_CHAR: + lUnoBoundaryType = 1; // CHARACTER; + break; + case IA2_TEXT_BOUNDARY_WORD: + lUnoBoundaryType = 2; // WORD; + break; + case IA2_TEXT_BOUNDARY_SENTENCE: + lUnoBoundaryType = 3; // SENTENCE; + break; + case IA2_TEXT_BOUNDARY_LINE: + lUnoBoundaryType = 5; // LINE; + break; + case IA2_TEXT_BOUNDARY_PARAGRAPH: + lUnoBoundaryType = 4; + break; + case IA2_TEXT_BOUNDARY_ALL: + { + long nChar; + get_nCharacters( &nChar ); + *startOffset = 0; + *endOffset = nChar; + return get_text(0, nChar, text); + } + break; + default: + return E_FAIL; + } + + TextSegment segment = GetXInterface()->getTextBeforeIndex( offset, sal_Int16(lUnoBoundaryType)); + ::rtl::OUString ouStr = segment.SegmentText; + SysFreeString(*text); + *text = SysAllocString((OLECHAR*)ouStr.getStr()); + *startOffset = segment.SegmentStart; + *endOffset = segment.SegmentEnd; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special text after some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_textAfterOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (startOffset == NULL || endOffset == NULL || text == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + // In New UNO IAccessibleText.idl these constant values are defined as follows: + // + // const long TEXT_BOUNDARY_CHAR = -1; + // const long TEXT_BOUNDARY_TO_CURSOR_POS = -2; + // const long TEXT_BOUNDARY_START_OF_WORD = -3; + // const long TEXT_BOUNDARY_END_OF_WORD = -4; + // const long TEXT_BOUNDARY_START_OF_SENTENCE = -5; + // const long TEXT_BOUNDARY_END_OF_SENTENCE = -6; + // const long TEXT_BOUNDARY_START_OF_LINE = -7; + // const long TEXT_BOUNDARY_END_OF_LINE = -8; + // + // In UNO, the corresponding values are as follows: + // + // const short CHARACTER = 1; + // const short WORD = 2; + // const short SENTENCE = 3; + // const short PARAGRAPH = 4; + // const short LINE = 5; + // const short GLYPH = 6; + // const short ATTRIBUTE_RUN = 7; + // + + long lUnoBoundaryType; + switch(boundaryType) + { + case IA2_TEXT_BOUNDARY_CHAR: + lUnoBoundaryType = 1; // CHARACTER; + break; + case IA2_TEXT_BOUNDARY_WORD: + lUnoBoundaryType = 2; // WORD; + break; + case IA2_TEXT_BOUNDARY_SENTENCE: + lUnoBoundaryType = 3; // SENTENCE; + break; + case IA2_TEXT_BOUNDARY_LINE: + lUnoBoundaryType = 5; // LINE; + break; + case IA2_TEXT_BOUNDARY_PARAGRAPH: + lUnoBoundaryType = 4; + break; + case IA2_TEXT_BOUNDARY_ALL: + { + long nChar; + get_nCharacters( &nChar ); + *startOffset = 0; + *endOffset = nChar; + return get_text(0, nChar, text); + } + break; + default: + return E_FAIL; + } + + TextSegment segment = GetXInterface()->getTextBehindIndex( offset, sal_Int16(lUnoBoundaryType)); + ::rtl::OUString ouStr = segment.SegmentText; + SysFreeString(*text); + *text = SysAllocString((OLECHAR*)ouStr.getStr()); + *startOffset = segment.SegmentStart; + *endOffset = segment.SegmentEnd; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get special text at some position. + * @param offset Special position. + * @param boundaryType Boundary type. + * @param startOffset Variant to accept the start offset. + * @param endOffset Variant to accept the end offset. + * @param text Variant to accept the special text. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_textAtOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) +{ + + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (startOffset == NULL || text == NULL ||endOffset == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + // In New UNO IAccessibleText.idl these constant values are defined as follows: + // + // const long TEXT_BOUNDARY_CHAR = -1; + // const long TEXT_BOUNDARY_TO_CURSOR_POS = -2; + // const long TEXT_BOUNDARY_START_OF_WORD = -3; + // const long TEXT_BOUNDARY_END_OF_WORD = -4; + // const long TEXT_BOUNDARY_START_OF_SENTENCE = -5; + // const long TEXT_BOUNDARY_END_OF_SENTENCE = -6; + // const long TEXT_BOUNDARY_START_OF_LINE = -7; + // const long TEXT_BOUNDARY_END_OF_LINE = -8; + // + // In UNO, the corresponding values are as follows: + // + // const short CHARACTER = 1; + // const short WORD = 2; + // const short SENTENCE = 3; + // const short PARAGRAPH = 4; + // const short LINE = 5; + // const short GLYPH = 6; + // const short ATTRIBUTE_RUN = 7; + // + + long lUnoBoundaryType; + + switch(boundaryType) + { + case IA2_TEXT_BOUNDARY_CHAR: + lUnoBoundaryType = 1; // CHARACTER; + break; + case IA2_TEXT_BOUNDARY_WORD: + lUnoBoundaryType = 2; // WORD; + break; + case IA2_TEXT_BOUNDARY_SENTENCE: + lUnoBoundaryType = 3; // SENTENCE; + break; + case IA2_TEXT_BOUNDARY_LINE: + lUnoBoundaryType = 5; // LINE; + break; + case IA2_TEXT_BOUNDARY_PARAGRAPH: + lUnoBoundaryType = 4; + break; + case IA2_TEXT_BOUNDARY_ALL: + { + long nChar; + get_nCharacters( &nChar ); + *startOffset = 0; + *endOffset = nChar; + return get_text(0, nChar, text); + } + break; + default: + return E_FAIL; + } + + TextSegment segment = GetXInterface()->getTextAtIndex( offset, sal_Int16(lUnoBoundaryType)); + ::rtl::OUString ouStr = segment.SegmentText; + SysFreeString(*text); + *text = SysAllocString((OLECHAR*)ouStr.getStr()); + *startOffset = segment.SegmentStart; + *endOffset = segment.SegmentEnd; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Remove selection. + * @param selectionIndex Special selection index + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::removeSelection(long selectionIndex) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK XInterface# + if(pUNOInterface == NULL) + { + return E_FAIL; + } + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + + Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); + + if( pRExtension.is() ) + { + pRExtension->removeSelection(selectionIndex); + return S_OK; + } + else + { + GetXInterface()->setSelection(0, 0); + return S_OK; + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Set caret position. + * @param offset Special position. + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::setCaretOffset(long offset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK XInterface# + if(!pRXText.is()) + return E_FAIL; + + GetXInterface()->setCaretPosition( offset); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Set special selection. + * @param selectionIndex Special selection index. + * @param startOffset start position. + * @param endOffset end position. + * @param success Variant to accept the memthod called result. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::setSelection(long, long startOffset, long endOffset) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + // #CHECK XInterface# + if(!pRXText.is()) + { + return E_FAIL; + } + + GetXInterface()->setSelection( startOffset, endOffset ); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get characters count. + * @param nCharacters Variant to accept the characters count. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::get_nCharacters(long * nCharacters) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (nCharacters == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + if(!pRXText.is()) + { + *nCharacters = 0; + return S_OK; + } + + *nCharacters = GetXInterface()->getCharacterCount(); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +// added by qiuhd, 2006/07/03, for direver 07/11 +STDMETHODIMP CAccTextBase::get_newText( IA2TextSegment *) +{ + return E_NOTIMPL; +} + +STDMETHODIMP CAccTextBase::get_oldText( IA2TextSegment *) +{ + return E_NOTIMPL; +} + +/** + * Scroll to special sub-string . + * @param startIndex Start index of sub string. + * @param endIndex End index of sub string. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::scrollSubstringToPoint(long, long, IA2CoordinateType, long, long ) +{ + + + ENTER_PROTECTED_BLOCK + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CAccTextBase::scrollSubstringTo(long, long, IA2ScrollType) +{ + + + ENTER_PROTECTED_BLOCK + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Put UNO interface. + * @param pXInterface UNO interface. + * @return Result. +*/ +STDMETHODIMP CAccTextBase::put_XInterface(long pXInterface) +{ + + CHECK_ENABLE_INF + + 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<XAccessibleText> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pRXText = NULL; + else + pRXText = pRXI; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +OUString ReplaceOneChar(OUString oldOUString, OUString replacedChar, OUString replaceStr) +{ + int iReplace = -1; + iReplace = oldOUString.lastIndexOf(replacedChar); + if (iReplace > -1) + { + for(;iReplace>-1;) + { + oldOUString = oldOUString.replaceAt(iReplace,1, replaceStr); + iReplace=oldOUString.lastIndexOf(replacedChar,iReplace); + } + } + return oldOUString; + +} +OUString ReplaceFourChar(OUString oldOUString) +{ + oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii("\\"),OUString::createFromAscii("\\\\")); + oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii(";"),OUString::createFromAscii("\\;")); + oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii("="),OUString::createFromAscii("\\=")); + oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii(","),OUString::createFromAscii("\\,")); + oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii(":"),OUString::createFromAscii("\\:")); + return oldOUString; +} diff --git a/winaccessibility/source/UAccCOM/AccTextBase.h b/winaccessibility/source/UAccCOM/AccTextBase.h new file mode 100644 index 000000000000..3e22ba013eaf --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccTextBase.h @@ -0,0 +1,122 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +// AccTextBase.h: interface for the CAccTextBase class. +// +////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_ACCTEXTBASE_H__B9AE05F6_E28B_4CF3_A8F2_EEE5D2E00B82__INCLUDED_) +#define AFX_ACCTEXTBASE_H__B9AE05F6_E28B_4CF3_A8F2_EEE5D2E00B82__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define WNT + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleText.hpp> +#include "UNOXWrapper.h" + +class ATL_NO_VTABLE CAccTextBase : public CUNOXWrapper +{ +public: + CAccTextBase(); + virtual ~CAccTextBase(); + + // IAccessibleText +public: + // IAccessibleText + + // Adds a text selection. + STDMETHOD(get_addSelection)(long startOffset, long endOffset); + + // Gets text attributes. + STDMETHOD(get_attributes)(long offset, long * startOffset, long * endOffset, BSTR * textAttributes); + + // Gets caret offset. + STDMETHOD(get_caretOffset)(long * offset); + + // Gets total number of characters. + STDMETHOD(get_characterCount)(long * nCharacters); + + // Gets bounding rect containing the glyph(s) representing the character + // at the specified text offset + STDMETHOD(get_characterExtents)(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height); + + // Gets number of active non-contiguous selections. + STDMETHOD(get_nSelections)(long * nSelections); + + // Gets bounding rect for the glyph at a certain point. + STDMETHOD(get_offsetAtPoint)(long x, long y, IA2CoordinateType coordType, long * offset); + + // Gets character offsets of N-th active text selection. + STDMETHOD(get_selection)(long selectionIndex, long * startOffset, long * endOffset); + + // Gets a range of text by offset NOTE: returned string may be longer + // than endOffset-startOffset bytes if text contains multi-byte characters. + STDMETHOD(get_text)(long startOffset, long endOffset, BSTR * text); + + // Gets a specified amount of text that ends before a specified offset. + STDMETHOD(get_textBeforeOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Gets a specified amount of text that spans the specified offset. + STDMETHOD(get_textAfterOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Gets a specified amount of text that starts after a specified offset. + STDMETHOD(get_textAtOffset)(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text); + + // Unselects a range of text. + STDMETHOD(removeSelection)(long selectionIndex); + + // Moves text caret. + STDMETHOD(setCaretOffset)(long offset); + + // Changes the bounds of an existing selection. + STDMETHOD(setSelection)(long selectionIndex, long startOffset, long endOffset); + + // Gets total number of characters. + // NOTE: this may be different than the total number of bytes required + // to store the text, if the text contains multi-byte characters. + STDMETHOD(get_nCharacters)(long * nCharacters); + + STDMETHOD(get_newText)( IA2TextSegment *newText); + + STDMETHOD(get_oldText)( IA2TextSegment *oldText); + + // Makes specific part of string visible on screen. + STDMETHOD(scrollSubstringTo)(long startIndex, long endIndex,enum IA2ScrollType scrollType); + STDMETHOD(scrollSubstringToPoint)(long startIndex, long endIndex,enum IA2CoordinateType coordinateType, long x, long y ); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleText> pRXText; + + inline com::sun::star::accessibility::XAccessibleText* GetXInterface() + { + return pRXText.get(); + } +}; + +#endif // !defined(AFX_ACCTEXTBASE_H__B9AE05F6_E28B_4CF3_A8F2_EEE5D2E00B82__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccValue.cxx b/winaccessibility/source/UAccCOM/AccValue.cxx new file mode 100644 index 000000000000..60c7af88cf20 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccValue.cxx @@ -0,0 +1,224 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "AccValue.h" +#include "MAccessible.h" +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +/** + * Get current value. + * @param currentValue Variant that accepts current value. + * @return Result. + */ + +STDMETHODIMP CAccValue::get_currentValue(VARIANT * currentValue) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (currentValue == NULL) + return E_INVALIDARG; + if ( !pRXVal.is() ) + return E_FAIL; + + // Get Any type value from UNO. + ::com::sun::star::uno::Any anyVal = GetXInterface()->getCurrentValue(); + // Convert Any to VARIANT. + CMAccessible::ConvertAnyToVariant(anyVal, currentValue); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Set current value. + * @param Value New value should be set. + * @param success If the method is successfully called. + * @return Result. + */ +STDMETHODIMP CAccValue::setCurrentValue(VARIANT value) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if ( !pRXVal.is() ) + return E_FAIL; + + HRESULT hRet = S_OK; + ::com::sun::star::uno::Any anyVal; + + // Set value according to value type. + switch(value.vt) + { + case VT_UI1: + { + ::com::sun::star::uno::Type typeInfo(TypeClass_CHAR, (sal_Char *)"char"); + anyVal.setValue(&value.bVal, typeInfo); + } + break; + + case VT_BOOL: + { + ::com::sun::star::uno::Type typeInfo(TypeClass_BOOLEAN, (sal_Char *)"bool"); + anyVal.setValue(&value.boolVal, typeInfo); + } + break; + + case VT_I2: + { + ::com::sun::star::uno::Type typeInfo(TypeClass_SHORT, (sal_Char *)"short"); + anyVal.setValue(&value.iVal, typeInfo); + } + break; + + case VT_I4: + { + ::com::sun::star::uno::Type typeInfo(TypeClass_LONG, (sal_Char *)"long"); + anyVal.setValue(&value.lVal, typeInfo); + } + break; + + case VT_R4: + { + ::com::sun::star::uno::Type typeInfo(TypeClass_FLOAT, (sal_Char *)"float"); + anyVal.setValue(&value.fltVal, typeInfo); + } + break; + + case VT_R8: + { + ::com::sun::star::uno::Type typeInfo(TypeClass_DOUBLE, (sal_Char *)"double"); + anyVal.setValue(&value.dblVal, typeInfo); + } + break; + + default: + { + // Unsupport type conversion. + hRet = E_FAIL; + } + break; + } + + if(hRet == S_OK) + { + hRet = pRXVal->setCurrentValue(anyVal) ? S_OK : E_FAIL ; + } + + return hRet; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get maximum value. + * @param maximumValue Variant that accepts maximum value. + * @return Result. + */ +STDMETHODIMP CAccValue::get_maximumValue(VARIANT *maximumValue) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (maximumValue == NULL) + return E_INVALIDARG; + if ( !pRXVal.is() ) + return E_FAIL; + + // Get Any type value from UNO. + ::com::sun::star::uno::Any anyVal = GetXInterface()->getMaximumValue(); + // Convert Any to VARIANT. + CMAccessible::ConvertAnyToVariant(anyVal, maximumValue); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Get minimum value. + * @param mininumValue Variant that accepts minimum value. + * @return Result. + */ +STDMETHODIMP CAccValue::get_minimumValue(VARIANT *mininumValue) +{ + + CHECK_ENABLE_INF + + ENTER_PROTECTED_BLOCK + + if (mininumValue == NULL) + return E_FAIL; + if ( !pRXVal.is() ) + return E_FAIL; + + // Get Any type value from UNO. + ::com::sun::star::uno::Any anyVal = GetXInterface()->getMinimumValue(); + // Convert Any to VARIANT. + CMAccessible::ConvertAnyToVariant(anyVal, mininumValue); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** + * Put valid UNO interface into com class. + * @param pXInterface UNO interface. + * @return Result. + */ +STDMETHODIMP CAccValue::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<XAccessibleValue> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + pRXVal = NULL; + else + pRXVal = pRXI.get(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} diff --git a/winaccessibility/source/UAccCOM/AccValue.h b/winaccessibility/source/UAccCOM/AccValue.h new file mode 100644 index 000000000000..674f1e70d1e3 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccValue.h @@ -0,0 +1,104 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#if !defined(AFX_ACCVALUE_H__CBA4972C_4188_4A18_A3CD_4A1FA3DDED38__INCLUDED_) +#define AFX_ACCVALUE_H__CBA4972C_4188_4A18_A3CD_4A1FA3DDED38__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "resource.h" // main symbols + + +#include <com/sun/star/uno/reference.hxx> +#include <com/sun/star/accessibility/XAccessibleValue.hpp> +#include "UNOXWrapper.h" + +/** + * CAccValue implements IAccessibleValue interface. + */ +class CAccValue : + public CComObjectRoot, + public CComCoClass<CAccValue,&CLSID_AccValue>, + public IAccessibleValue, + public CUNOXWrapper +{ +public: + CAccValue() + { + } + virtual ~CAccValue() + { + } + + BEGIN_COM_MAP(CAccValue) + COM_INTERFACE_ENTRY(IAccessibleValue) + COM_INTERFACE_ENTRY(IUNOXWrapper) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CAccValue*)pv)->SmartQI(iid,ppvObject); + } + + HRESULT SmartQI(REFIID iid, void** ppvObject) + { + if( m_pOuterUnknown ) + return OuterQueryInterface(iid,ppvObject); + return E_FAIL; + } + + DECLARE_REGISTRY_RESOURCEID(IDR_AccValue) + + // IAccessibleValue +public: + // IAccessibleValue + + // Returns the value of this object as a number. + STDMETHOD(get_currentValue)(VARIANT *currentValue); + + // Sets the value of this object to the given number. + STDMETHOD(setCurrentValue)(VARIANT value); + + // Returns the maximal value that can be represented by this object. + STDMETHOD(get_maximumValue)(VARIANT *maximumValue); + + // Returns the minimal value that can be represented by this object. + STDMETHOD(get_minimumValue)(VARIANT *mininumValue); + + // Overide of IUNOXWrapper. + STDMETHOD(put_XInterface)(long pXInterface); + +private: + + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleValue> pRXVal; + + inline com::sun::star::accessibility::XAccessibleValue* GetXInterface() + { + return pRXVal.get(); + } + +}; + +#endif // !defined(AFX_ACCVALUE_H__CBA4972C_4188_4A18_A3CD_4A1FA3DDED38__INCLUDED_) diff --git a/winaccessibility/source/UAccCOM/AccValue.rgs b/winaccessibility/source/UAccCOM/AccValue.rgs new file mode 100644 index 000000000000..f57f318379ec --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccValue.rgs @@ -0,0 +1,23 @@ +HKCR +{ + UAccCOM.AccValue.1 = s 'AccValue Class' + { + CLSID = s '{730A561B-1AF6-49E1-9C04-9A2F48CD8512}' + } + UAccCOM.AccValue = s 'AccValue Class' + { + CLSID = s '{730A561B-1AF6-49E1-9C04-9A2F48CD8512}' + } + NoRemove CLSID + { + ForceRemove {730A561B-1AF6-49E1-9C04-9A2F48CD8512} = s 'AccValue Class' + { + ProgID = s 'UAccCOM.AccValue.1' + VersionIndependentProgID = s 'UAccCOM.AccValue' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'both' + } + } + } +} diff --git a/winaccessibility/source/UAccCOM/AccessibleKeyStroke.h b/winaccessibility/source/UAccCOM/AccessibleKeyStroke.h new file mode 100644 index 000000000000..f29b116571f1 --- /dev/null +++ b/winaccessibility/source/UAccCOM/AccessibleKeyStroke.h @@ -0,0 +1,157 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __ACCESSIBLEKEYSTROKE_H_ +#define __ACCESSIBLEKEYSTROKE_H_ + +#pragma once + +typedef struct _ACCESSIBLE_KEYSTROKE { + short modifiers; + short keyCode; + char keyChar; + short keyFunc; +} ACCESSIBLE_KEYSTROKE; + +const short MODIFIER_SHIFT = 1; +const short MODIFIER_CTRL = 2; +const short MODIFIER_ALT = 4; + +const short KEYCODE_NUM0 = 256; +const short KEYCODE_NUM1 = 257; +const short KEYCODE_NUM2 = 258; +const short KEYCODE_NUM3 = 259; +const short KEYCODE_NUM4 = 260; +const short KEYCODE_NUM5 = 261; +const short KEYCODE_NUM6 = 262; +const short KEYCODE_NUM7 = 263; +const short KEYCODE_NUM8 = 264; +const short KEYCODE_NUM9 = 265; +const short KEYCODE_A = 512; +const short KEYCODE_B = 513; +const short KEYCODE_C = 514; +const short KEYCODE_D = 515; +const short KEYCODE_E = 516; +const short KEYCODE_F = 517; +const short KEYCODE_G = 518; +const short KEYCODE_H = 519; +const short KEYCODE_I = 520; +const short KEYCODE_J = 521; +const short KEYCODE_K = 522; +const short KEYCODE_L = 523; +const short KEYCODE_M = 524; +const short KEYCODE_N = 525; +const short KEYCODE_O = 526; +const short KEYCODE_P = 527; +const short KEYCODE_Q = 528; +const short KEYCODE_R = 529; +const short KEYCODE_S = 530; +const short KEYCODE_T = 531; +const short KEYCODE_U = 532; +const short KEYCODE_V = 533; +const short KEYCODE_W = 534; +const short KEYCODE_X = 535; +const short KEYCODE_Y = 536; +const short KEYCODE_Z = 537; +const short KEYCODE_F1 = 768; +const short KEYCODE_F2 = 769; +const short KEYCODE_F3 = 770; +const short KEYCODE_F4 = 771; +const short KEYCODE_F5 = 772; +const short KEYCODE_F6 = 773; +const short KEYCODE_F7 = 774; +const short KEYCODE_F8 = 775; +const short KEYCODE_F9 = 776; +const short KEYCODE_F10 = 777; +const short KEYCODE_F11 = 778; +const short KEYCODE_F12 = 779; +const short KEYCODE_F13 = 780; +const short KEYCODE_F14 = 781; +const short KEYCODE_F15 = 782; +const short KEYCODE_F16 = 783; +const short KEYCODE_F17 = 784; +const short KEYCODE_F18 = 785; +const short KEYCODE_F19 = 786; +const short KEYCODE_F20 = 787; +const short KEYCODE_F21 = 788; +const short KEYCODE_F22 = 789; +const short KEYCODE_F23 = 790; +const short KEYCODE_F24 = 791; +const short KEYCODE_F25 = 792; +const short KEYCODE_F26 = 793; +const short KEYCODE_DOWN = 1024; +const short KEYCODE_UP = 1025; +const short KEYCODE_LEFT = 1026; +const short KEYCODE_RIGHT = 1027; +const short KEYCODE_HOME = 1028; +const short KEYCODE_END = 1029; +const short KEYCODE_PAGEUP = 1030; +const short KEYCODE_PAGEDOWN = 1031; +const short KEYCODE_RETURN = 1280; +const short KEYCODE_ESCAPE = 1281; +const short KEYCODE_TAB = 1282; +const short KEYCODE_BACKSPACE = 1283; +const short KEYCODE_SPACE = 1284; +const short KEYCODE_INSERT = 1285; +const short KEYCODE_DELETE = 1286; +const short KEYCODE_ADD = 1287; +const short KEYCODE_SUBTRACT = 1288; +const short KEYCODE_MULTIPLY = 1289; +const short KEYCODE_DIVIDE = 1290; +const short KEYCODE_POINT = 1291; +const short KEYCODE_COMMA = 1292; +const short KEYCODE_LESS = 1293; +const short KEYCODE_GREATER = 1294; +const short KEYCODE_EQUAL = 1295; +const short KEYCODE_OPEN = 1296; +const short KEYCODE_CUT = 1297; +const short KEYCODE_COPY = 1298; +const short KEYCODE_PASTE = 1299; +const short KEYCODE_UNDO = 1300; +const short KEYCODE_REPEAT = 1301; +const short KEYCODE_FIND = 1302; +const short KEYCODE_PROPERTIES = 1303; +const short KEYCODE_FRONT = 1304; +const short KEYCODE_CONTEXTMENU = 1305; +const short KEYCODE_HELP = 1306; + +const short SHORTCUT_DONTKNOW = 0; +const short NEW = 1; +const short OPEN = 2; +const short SAVE = 3; +const short SAVEAS = 4; +const short PRINT = 5; +const short CLOSE = 6; +const short QUIT = 7; +const short CUT = 8; +const short COPY = 9; +const short PASTE = 10; +const short UNDO = 11; +const short REDO = 12; +const short UNODELETE = 13; +const short REPEAT = 14; +const short FIND = 15; +const short FINDBACKWARD = 16; +const short PROPERTIES = 17; +const short FRONT = 18; + + +#endif //#define __ACCESSIBLEKEYSTROKE_H_ diff --git a/winaccessibility/source/UAccCOM/CheckEnableAccessible.cxx b/winaccessibility/source/UAccCOM/CheckEnableAccessible.cxx new file mode 100644 index 000000000000..fa61021c388c --- /dev/null +++ b/winaccessibility/source/UAccCOM/CheckEnableAccessible.cxx @@ -0,0 +1,35 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#define WNT +#define _USE_NAMESPACE + +#ifndef _SV_SVAPP_HXX +#include <vcl/svapp.hxx> +#endif + +#include "CheckEnableAccessible.h" + + +bool IsEnableAccessibleInterface() +{ + return Application::IsEnableAccessInterface(); +} diff --git a/winaccessibility/source/UAccCOM/CheckEnableAccessible.h b/winaccessibility/source/UAccCOM/CheckEnableAccessible.h new file mode 100644 index 000000000000..729817dc6f86 --- /dev/null +++ b/winaccessibility/source/UAccCOM/CheckEnableAccessible.h @@ -0,0 +1,30 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef _CHECKENABLEACCESSIBLE_HXX +#define _CHECKENABLEACCESSIBLE_HXX + +bool IsEnableAccessibleInterface(); + +#define CHECK_ENABLE_INF if(!IsEnableAccessibleInterface()){ return S_FALSE; } +#define CHECK_ENABLE_INF_ZERO if(!IsEnableAccessibleInterface()){ return 0; } + +#endif //_CHECKENABLEACCESSIBLE_HXX diff --git a/winaccessibility/source/UAccCOM/EnumVariant.cxx b/winaccessibility/source/UAccCOM/EnumVariant.cxx new file mode 100644 index 000000000000..271b288df42b --- /dev/null +++ b/winaccessibility/source/UAccCOM/EnumVariant.cxx @@ -0,0 +1,227 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "EnumVariant.h" +#include "MAccessible.h" + +#include "act.hxx" + +///////////////////////////////////////////////////////////////////////////// +// CEnumVariant + + + +/** + * enumarate method,get next element + * @param cElements The number of elements to be returned. + * @param pvar An array of at least size celt in which the elements are to be returned. + * @param pcElementFetched Pointer to the number of elements returned in rgVar, or Null¡£ + * @return Result. + */ +HRESULT STDMETHODCALLTYPE CEnumVariant::Next(ULONG cElements,VARIANT __RPC_FAR *pvar,ULONG __RPC_FAR *pcElementFetched) +{ + long l1; + ULONG l2; + + if (pvar == NULL) + return E_INVALIDARG; + + CHECK_ENABLE_INF + if (pcElementFetched != NULL) + *pcElementFetched = 0; + + // Retrieve the next cElements. + for (l1=m_lCurrent, l2=0; l1<m_pXAccessibleSelection->getSelectedAccessibleChildCount() && + l2<cElements; l1++, l2++) + { + Reference< XAccessible > pRXAcc = m_pXAccessibleSelection->getSelectedAccessibleChild(l1); + IAccessible* pChild = NULL; + BOOL isGet = CMAccessible::get_IAccessibleFromXAccessible((long)pRXAcc.get(),&pChild); + if(isGet) + { + pvar[l2].vt = VT_I4; + ((IMAccessible*)pChild)->Get_XAccChildID(&pvar[l2].lVal); + } + else if(pRXAcc.is()) + { + if(CMAccessible::g_pAgent) + CMAccessible::g_pAgent->InsertAccObj(pRXAcc.get(),pUNOInterface,NULL); + BOOL isGet = CMAccessible::get_IAccessibleFromXAccessible((long)pRXAcc.get(),&pChild); + if(isGet) + { + pvar[l2].vt = VT_I4; + ((IMAccessible*)pChild)->Get_XAccChildID(&pvar[l2].lVal); + } + } + } + // Set count of elements retrieved. + if (pcElementFetched != NULL) + *pcElementFetched = l2; + m_lCurrent = l1; + + return (l2 < cElements) ? S_FALSE : NOERROR; +} + +/** + * skip the elements in the given range when enumarate elements + * @param cElements The number of elements to skip. + * @return Result. + */ +HRESULT STDMETHODCALLTYPE CEnumVariant::Skip(ULONG cElements) +{ + CHECK_ENABLE_INF + m_lCurrent += cElements; + if (m_lCurrent > (long)(m_lLBound+m_pXAccessibleSelection->getSelectedAccessibleChildCount())) + { + m_lCurrent = m_lLBound+m_pXAccessibleSelection->getSelectedAccessibleChildCount(); + return E_FAIL; + } + else + return NOERROR; +} + + +/** + * reset the enumaration position to initial value + * @param + * @return Result. + */ +HRESULT STDMETHODCALLTYPE CEnumVariant::Reset( void) +{ + m_lCurrent = m_lLBound; + return NOERROR; +} + + +/** + *create a new IEnumVariant object, + *copy current enumaration container and its state to + *the new object + *AT will use the copy object to get elements + * @param ppenum On return, pointer to the location of the clone enumerator¡£ + * @return Result. + */ +HRESULT STDMETHODCALLTYPE CEnumVariant::Clone(IEnumVARIANT __RPC_FAR *__RPC_FAR *ppenum) +{ + CEnumVariant * penum = NULL; + HRESULT hr; + if (ppenum == NULL) + return E_INVALIDARG; + + *ppenum = NULL; + + hr = Create(&penum); + if( hr == S_OK ) + { + penum->PutSelection((long)pUNOInterface); + *ppenum = penum; + } + else + { + if (penum) + penum->Release(); + } + return hr; +} + +/** + *Static public method to create a CLSID_EnumVariant com object. + * @param ppenum Pointer to accept com object. + * @return Result. + */ +HRESULT STDMETHODCALLTYPE CEnumVariant::Create(CEnumVariant __RPC_FAR *__RPC_FAR *ppenum) +{ + ActivateActContext(); + HRESULT hr = CoCreateInstance(CLSID_EnumVariant,NULL, + CLSCTX_SERVER,IID_IEnumVariant,(void **)ppenum); + DeactivateActContext(); + if (S_OK != hr) + { + return E_FAIL; + } + + return S_OK; +} + +/** + *Return count of elements in current container + * @param. + * @return count of elements in current container. + */ +long CEnumVariant::GetCountOfElements() +{ + CHECK_ENABLE_INF_ZERO + + if(m_pXAccessibleSelection.is()) + return m_pXAccessibleSelection->getSelectedAccessibleChildCount(); + return 0; +} + +/** + * Set memeber m_pXAccessibleSelection to NULL and m_lCurrent to m_lLBound. + * @param. + * @return Result + */ +STDMETHODIMP CEnumVariant::ClearEnumeration() +{ + pUNOInterface = NULL; + m_pXAccessibleSelection = NULL; + m_lCurrent = m_lLBound; + return S_OK; +} + +/** + *Static method to fetch XAccessibleSelection + * @param pXAcc XAccessible interface. + * @return XAccessibleSelection interface. + */ +static Reference<XAccessibleSelection> GetXAccessibleSelection(XAccessible* pXAcc) +{ + XAccessibleSelection* pSelection = NULL; + Reference< XAccessibleContext > pRContext; + + if( pXAcc == NULL) + return NULL; + + pRContext = pXAcc->getAccessibleContext(); + if( !pRContext.is() ) + return NULL; + + Reference< XAccessibleSelection > pRSelection(pRContext,UNO_QUERY); + if( !pRSelection.is() ) + return NULL; + + return pRSelection; +} + +/** + * Put valid UNO XAccessible interface. + * @param pXSelection XAccessible interface. + * @return Result.. + */ +STDMETHODIMP CEnumVariant::PutSelection(long pXSelection) +{ + pUNOInterface = (XAccessible*)pXSelection; + m_pXAccessibleSelection = GetXAccessibleSelection(pUNOInterface); + return S_OK; +} diff --git a/winaccessibility/source/UAccCOM/EnumVariant.h b/winaccessibility/source/UAccCOM/EnumVariant.h new file mode 100644 index 000000000000..1089abdf6415 --- /dev/null +++ b/winaccessibility/source/UAccCOM/EnumVariant.h @@ -0,0 +1,106 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __ENUMVARIANT_H_ +#define __ENUMVARIANT_H_ + +#define WNT + +#include "resource.h" // main symbols +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleSelection.hpp> +#include "UAccCOM2.h" +#include <AccObjectManagerAgent.hxx> + +using namespace com::sun::star::accessibility; +using namespace com::sun::star::uno; + +#include <vector> +#include <algorithm> +using namespace std; + +/** + * CEnumVariant implements IEnumVARIANT interface. + */ +class ATL_NO_VTABLE CEnumVariant : + public CComObjectRootEx<CComMultiThreadModel>, + public CComCoClass<CEnumVariant, &CLSID_EnumVariant>, + public IDispatchImpl<IEnumVariant, &IID_IEnumVariant, &LIBID_UACCCOMLib> +{ +public: + CEnumVariant() + :m_lLBound(0), + pUNOInterface(NULL), + m_pXAccessibleSelection(NULL) + { + m_lCurrent = m_lLBound; + } + + virtual ~CEnumVariant() {}; + + DECLARE_REGISTRY_RESOURCEID(IDR_ENUMVARIANT) + + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CEnumVariant) + COM_INTERFACE_ENTRY(IEnumVariant) + COM_INTERFACE_ENTRY(IEnumVARIANT) + END_COM_MAP() + + // IEnumVariant +public: + + STDMETHOD(ClearEnumeration)(); + + // IEnumVARIANT + + // + HRESULT STDMETHODCALLTYPE Next(ULONG cElements,VARIANT __RPC_FAR *pvar,ULONG __RPC_FAR *pcElementFetched); + + // + HRESULT STDMETHODCALLTYPE Skip(ULONG cElements); + + // + HRESULT STDMETHODCALLTYPE Reset( void); + + // + HRESULT STDMETHODCALLTYPE Clone(IEnumVARIANT __RPC_FAR *__RPC_FAR *ppenum); + + // IEnumVariant + + // + HRESULT STDMETHODCALLTYPE PutSelection(long pXSelection); + + // + static HRESULT STDMETHODCALLTYPE Create(CEnumVariant __RPC_FAR *__RPC_FAR *ppenum); + + // + long GetCountOfElements(); + +private: + + long m_lCurrent; + long m_lLBound; + XAccessible* pUNOInterface; // XAccessible. + Reference<XAccessibleSelection> m_pXAccessibleSelection; // Selection. +}; + +#endif //__ENUMVARIANT_H_ diff --git a/winaccessibility/source/UAccCOM/EnumVariant.rgs b/winaccessibility/source/UAccCOM/EnumVariant.rgs new file mode 100644 index 000000000000..c5decdc4728f --- /dev/null +++ b/winaccessibility/source/UAccCOM/EnumVariant.rgs @@ -0,0 +1,26 @@ +HKCR +{ + UAccCOM.EnumVariant.1 = s 'EnumVariant Class' + { + CLSID = s '{152884E0-268B-4481-9AE7-1B372D3AA97F}' + } + UAccCOM.EnumVariant = s 'EnumVariant Class' + { + CLSID = s '{152884E0-268B-4481-9AE7-1B372D3AA97F}' + CurVer = s 'UAccCOM.EnumVariant.1' + } + NoRemove CLSID + { + ForceRemove {152884E0-268B-4481-9AE7-1B372D3AA97F} = s 'EnumVariant Class' + { + ProgID = s 'UAccCOM.EnumVariant.1' + VersionIndependentProgID = s 'UAccCOM.EnumVariant' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Both' + } + 'TypeLib' = s '{19ECB1B0-9376-4FF9-B580-223FC9C200B8}' + } + } +} diff --git a/winaccessibility/source/UAccCOM/MAccessible.cxx b/winaccessibility/source/UAccCOM/MAccessible.cxx new file mode 100644 index 000000000000..155c3afe70d8 --- /dev/null +++ b/winaccessibility/source/UAccCOM/MAccessible.cxx @@ -0,0 +1,3267 @@ +/************************************************************** +* +* 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. +* +*************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "MAccessible.h" + +#include <algorithm> +#include "AccAction.h" + +#include <com/sun/star/accessibility/XAccessibleText.hpp> +#include <com/sun/star/accessibility/XAccessibleEditableText.hpp> +#include <com/sun/star/accessibility/XAccessibleImage.hpp> +#include <com/sun/star/accessibility/XAccessibleTable.hpp> +#include <com/sun/star/accessibility/XAccessibleExtendedComponent.hpp> +#include <com/sun/star/accessibility/XAccessibleAction.hpp> +#include <com/sun/star/accessibility/XAccessibleKeyBinding.hpp> +#include <com/sun/star/accessibility/XAccessibleHyperText.hpp> +#include <com/sun/star/accessibility/XAccessibleHyperlink.hpp> +#include <com/sun/star/accessibility/XAccessibleRelationSet.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/XAccessibleGroupPosition.hpp> +#include <com/sun/star/accessibility/XAccessibleValue.hpp> +#include <com/sun/star/accessibility/XAccessibleExtendedAttributes.hpp> +#include <com/sun/star/style/LineSpacing.hpp> +#include <com/sun/star/style/TabStop.hpp> +#include <com/sun/star/container/XIndexReplace.hpp> + +#include "act.hxx" + +using namespace com::sun::star::accessibility::AccessibleStateType; + +// IA2 states mapping, and name +// maintenance the consistency, change one array, change the three all +long IA2_STATES[] = +{ + IA2_STATE_ACTIVE, // = 0x1; + IA2_STATE_ARMED, // = 0x2; + IA2_STATE_DEFUNCT, // = 0x4; + IA2_STATE_EDITABLE, // = 0x8; + IA2_STATE_HORIZONTAL, // = 0x10; + IA2_STATE_ICONIFIED, // = 0x20; + IA2_STATE_INVALID_ENTRY, // = 0x80; + IA2_STATE_MANAGES_DESCENDANTS, // = 0x100; + IA2_STATE_MODAL, // = 0x200; + IA2_STATE_MULTI_LINE, // = 0x400; + IA2_STATE_OPAQUE, // = 0x800; + IA2_STATE_REQUIRED, // = 0x2000; + IA2_STATE_SELECTABLE_TEXT, // = 0x3000; + IA2_STATE_SINGLE_LINE, // = 0x4000; + IA2_STATE_STALE, // = 0x8000; + IA2_STATE_SUPPORTS_AUTOCOMPLETION, // = 0x10000; + IA2_STATE_TRANSIENT, //= 0x20000; + IA2_STATE_VERTICAL // = 0x40000; +}; +/* + +<=== map ===> + +*/ +short UNO_STATES[] = +{ + ACTIVE, // = (sal_Int16)1; + ARMED, // = (sal_Int16)2; + DEFUNC, // = (sal_Int16)5; + EDITABLE, // = (sal_Int16)6; + HORIZONTAL, // = (sal_Int16)12; + ICONIFIED, // = (sal_Int16)13; + -1, //IA2_STATE_INVALID_ENTRY + MANAGES_DESCENDANTS, // = (sal_Int16)15; + MODAL, // = (sal_Int16)16; + MULTI_LINE, // = (sal_Int16)17; + OPAQUE, // = (sal_Int16)19; + -1, //IA2_STATE_REQUIRED + -1, //IA2_STATE_SELECTABLE_TEXT + SINGLE_LINE, // = (sal_Int16)26; + STALE, // = (sal_Int16)27; + -1, //IA2_STATE_SUPPORTS_AUTOCOMPLETION + TRANSIENT, //IA2_STATE_TRANSIENT + VERTICAL // = (sal_Int16)29; +}; + +// <=== map ===> + +BSTR IA2_STATES_NAME[] = +{ + _T("Active"), + _T("Armed"), + _T("Defunct"), + _T("Editable"), + _T("Horizontal"), + _T("Iconified"), + _T("Invalid Entry"), + _T("Manages Decendents"), + _T("Modal"), + _T("Multi Line"), + _T("Opaque"), + _T("Required"), + _T("Selectable Text"), + _T("Single Line"), + _T("Stale"), + _T("Supports Autocompletion"), + _T("Transient"), + _T("Vertical") +}; + +// IA2 states mapping, and name +// maintenance the consistency. change one, change them all + +BSTR UNO_ALL_STATES[] = +{ + _T("INVALID"), // INVALID ( 0 ) + _T("ACTIVE"), // ACTIVE ( 1 ) + _T("ARMED"), // ARMED ( 2 ) + _T("BUSY"), // BUSY ( 3 ) + _T("CHECKED"), // CHECKED ( 4 ) + _T("DEFUNC"), // DEFUNC ( 5 ) + _T("EDITABLE"), // EDITABLE ( 6 ) + _T("ENABLED"), // ENABLED ( 7 ) + _T("EXPANDABLE"), // EXPANDABLE ( 8 ) + _T("EXPANDED"), // EXPANDED ( 9 ) + _T("FOCUSABLE"), // FOCUSABLE ( 10 ) + _T("FOCUSED"), // FOCUSED ( 11 ) + _T("HORIZONTAL"), // HORIZONTAL ( 12 ) + _T("ICONIFIED"), // ICONIFIED ( 13 ) + _T("INDETERMINATE"), // INDETERMINATE ( 14 ) + _T("MANAGES_DESCENDANTS"),// MANAGES_DESCENDANTS ( 15 ) + _T("MODAL"), // MODAL ( 16 ) + _T("MULTI_LINE"), // MULTI_LINE ( 17 ) + _T("MULTI_SELECTABLE"), // MULTI_SELECTABLE ( 18 ) + _T("OPAQUE"), // OPAQUE ( 19 ) + _T("PRESSED"), // PRESSED ( 20 ) + _T("RESIZABLE"), // RESIZABLE ( 21 ) + _T("SELECTABLE"), // SELECTABLE ( 22 ) + _T("SELECTED"), // SELECTED ( 23 ) + _T("SENSITIVE"), // SENSITIVE ( 24 ) + _T("SHOWING"), // SHOWING ( 25 ) + _T("SINGLE_LINE"), // SINGLE_LINE ( 26 ) + _T("STALE"), // STALE ( 27 ) + _T("TRANSIENT"), // TRANSIENT ( 28 ) + _T("VERTICAL"), // VERTICAL ( 29 ) + _T("VISIBLE"), // VISIBLE ( 30 ) + _T("MOVEABLE"), // MOVEABLE ( 31 ) + _T("OFFSCREEN"), // OFFSCREEN ( 32 ) + _T("COLLAPSE"), // COLLAPSE ( 33 ) + _T("DEFAULT") // DEFAULT ( 34 ) +}; + + +using namespace com::sun::star::accessibility::AccessibleRole; + + + +#define QUERYXINTERFACE(ainterface) \ +{ \ + if(pXAcc == NULL) \ + return FALSE; \ + pRContext = pXAcc->getAccessibleContext(); \ + if( !pRContext.is() ) \ +{ \ + return FALSE; \ +} \ + Reference<X##ainterface> pRXI(pRContext,UNO_QUERY);\ + if( !pRXI.is() ) \ +{ \ + return FALSE; \ +} \ + *ppXI = (XInterface*)pRXI.get(); \ + return TRUE; \ +} + +#define ISDESTROY() \ + if(m_isDestroy) \ + return S_FALSE; + + +AccObjectManagerAgent* CMAccessible::g_pAgent = NULL; + +CMAccessible::CMAccessible(): +m_iRole(0x00), +m_dState(0x00), +m_dChildID(0x00), +m_dFocusChildID(UACC_NO_FOCUS), +m_hwnd(NULL), +m_pIParent(NULL), +m_pszName(NULL), +m_pszValue(NULL), +m_pszDescription(NULL), +m_isDestroy(FALSE), +m_pszActionDescription(NULL), +m_pXAction(NULL), +m_bRequiresSave(FALSE), +pUNOInterface(NULL) +{ + m_sLocation.m_dLeft=0; + m_sLocation.m_dTop = 0; + m_sLocation.m_dWidth=0; + m_sLocation.m_dHeight=0; + CEnumVariant::Create(&m_pEnumVar); +} + +CMAccessible::~CMAccessible() +{ + if(m_pszName!=NULL) + { + SAFE_SYSFREESTRING(m_pszName); + m_pszName=NULL; + } + if(m_pszValue!=NULL) + { + SAFE_SYSFREESTRING(m_pszValue); + m_pszValue=NULL; + } + if(m_pszDescription!=NULL) + { + SAFE_SYSFREESTRING(m_pszDescription); + m_pszDescription=NULL; + } + + if(m_pszActionDescription!=NULL) + { + SAFE_SYSFREESTRING(m_pszActionDescription); + m_pszActionDescription=NULL; + } + + if(m_pIParent) + { + m_pIParent->Release(); + m_pIParent=NULL; + } + pRef = NULL; + m_pEnumVar->Release(); + m_containedObjects.clear(); + pRContext = NULL; +} + +/** +* Returns the Parent IAccessible interface pointer to AT. +* It should add reference, and the client should release the component. +* It should return E_FAIL when the parent point is null. +* @param ppdispParent [in,out] used to return the parent interface point. +* when the point is null, should return null. +* @return S_OK if successful and E_FAIL if the m_pIParent is NULL. +*/ +STDMETHODIMP CMAccessible::get_accParent(IDispatch **ppdispParent) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(ppdispParent == NULL) + { + return E_INVALIDARG; + } + + if(m_pIParent) + { + *ppdispParent = m_pIParent; + (*ppdispParent)->AddRef(); + return S_OK; + } + else if(m_hwnd) + { + HRESULT hr = AccessibleObjectFromWindow(m_hwnd, OBJID_WINDOW, IID_IAccessible, (void**)ppdispParent); + if( ! SUCCEEDED( hr ) || ! ppdispParent ) + { + return S_FALSE; + } + return S_OK; + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns child count of current COM object. +* @param pcountChildren [in,out] used to return the children count. +* @return S_OK if successful. +*/ +STDMETHODIMP CMAccessible::get_accChildCount(long *pcountChildren) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pcountChildren == NULL) + { + return E_INVALIDARG; + } + + if(!pUNOInterface) + return S_FALSE; + + Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext(); + if( pRContext.is() ) + { + *pcountChildren = pRContext->getAccessibleChildCount(); + } + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns child interface pointer for AT according to input child ID. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param ppdispChild, [in,out] use to return the child interface point. +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::get_accChild(VARIANT varChild, IDispatch **ppdispChild) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(ppdispChild == NULL) + { + return E_INVALIDARG; + } + if(varChild.vt==VT_I4) + { + //get child interface pointer due to child ID + if(varChild.lVal==CHILDID_SELF) + { + AddRef(); + *ppdispChild = this; + return S_OK; + } + *ppdispChild = GetChildInterface(varChild.lVal); + (*ppdispChild)->AddRef(); + return (*ppdispChild)?S_OK:S_FALSE; + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the accessible name of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pszName, [in,out] use to return the name of the proper object. +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::get_accName(VARIANT varChild, BSTR *pszName) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pszName == NULL) + { + return E_INVALIDARG; + } + if(varChild.vt==VT_I4) + { + if(varChild.lVal==CHILDID_SELF) + { + SAFE_SYSFREESTRING(*pszName); + *pszName = SysAllocString(m_pszName); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->get_accName(varChild,pszName); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the accessible value of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pszValue, [in,out] use to return the value of the proper object. +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::get_accValue(VARIANT varChild, BSTR *pszValue) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if( pszValue == NULL ) + { + return E_INVALIDARG; + } + if( varChild.vt==VT_I4 ) + { + if(varChild.lVal==CHILDID_SELF) + { + if(m_dState & STATE_SYSTEM_PROTECTED) + return E_ACCESSDENIED; + + if ( m_pszValue !=NULL && wcslen(m_pszValue) == 0 ) + return S_OK; + + SAFE_SYSFREESTRING(*pszValue); + *pszValue = SysAllocString(m_pszValue); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->get_accValue(varChild,pszValue); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the accessible description of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pszDescription, [in,out] use to return the description of the proper object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::get_accDescription(VARIANT varChild, BSTR *pszDescription) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pszDescription == NULL) + { + return E_INVALIDARG; + } + if(varChild.vt==VT_I4) + { + if(varChild.lVal==CHILDID_SELF) + { + SAFE_SYSFREESTRING(*pszDescription); + *pszDescription = SysAllocString(m_pszDescription); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->get_accDescription(varChild,pszDescription); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the accessible role of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pvarRole, [in,out] use to return the role of the proper object. +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::get_accRole(VARIANT varChild, VARIANT *pvarRole) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarRole == NULL) + { + return E_INVALIDARG; + } + if(varChild.vt == VT_I4) + { + + if(varChild.lVal == CHILDID_SELF) + { + if( m_iRole < IA2_ROLE_CAPTION ) + { + VariantInit(pvarRole); + pvarRole->vt = VT_I4; + pvarRole->lVal = m_iRole; + } + else + { + VariantInit(pvarRole); + pvarRole->vt = VT_I4; + pvarRole->lVal = ROLE_SYSTEM_CLIENT; + } + return S_OK; + } + + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->get_accRole(varChild,pvarRole); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the accessible state of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pvarState, [in,out] use to return the state of the proper object. +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::get_accState(VARIANT varChild, VARIANT *pvarState) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarState == NULL) + { + return E_INVALIDARG; + } + if(varChild.vt==VT_I4) + { + if(varChild.lVal == CHILDID_SELF) + { + if(pUNOInterface) + { + Reference< XAccessibleContext > pContext = pUNOInterface->getAccessibleContext(); + if(pContext.is()) + { + // add the STATE_SYSTEM_LINKED state + Reference< XAccessibleHypertext > pRHypertext(pContext,UNO_QUERY); + if(pRHypertext.is()) + { + if( pRHypertext->getHyperLinkCount() > 0 ) + m_dState |= STATE_SYSTEM_LINKED; + else + m_dState &= ~STATE_SYSTEM_LINKED; + } + else + m_dState &= ~STATE_SYSTEM_LINKED; + } + } + + VariantInit(pvarState); + pvarState->vt = VT_I4; + pvarState->lVal = m_dState; + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->get_accState(varChild,pvarState); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the accessible helpString of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pszHelp, [in,out] use to return the helpString of the proper object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::get_accHelp(VARIANT, BSTR *) +{ + return E_NOTIMPL; +} + +/** +* Returns the accessible HelpTopic of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pszHelpFile, [in,out] use to return the HelpTopic of the proper object. +* @param pidTopic, use to return the HelpTopic ID of the proper object. +* @return S_OK if successful and E_FAIL if failure. +* Not implemented yet +*/ +STDMETHODIMP CMAccessible::get_accHelpTopic(BSTR *, VARIANT, long *) +{ + return E_NOTIMPL; +} + +static void GetMnemonicChar( const ::rtl::OUString& aStr, WCHAR* wStr) +{ + int nLen = aStr.pData->length; + int i = 0; + WCHAR* text = aStr.pData->buffer; + + while ( i < nLen ) + { + if ( text[i] == L'~' ) + if ( text[i+1] != L'~' ) + { + wStr[0] = text[i+1]; + break; + } + i++; + } +} + +/** +* Returns the accessible keyboard shortcut of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pszKeyboardShortcut, [in,out] use to return the kbshortcut of the proper object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + + ISDESTROY() + // #CHECK# + if(pszKeyboardShortcut == NULL) + { + return E_INVALIDARG; + } + + if(varChild.vt==VT_I4) + { + if(varChild.lVal == CHILDID_SELF) + { + if( pUNOInterface ) + { + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + return S_FALSE; + + Reference<XAccessibleAction> pRXI(pRContext,UNO_QUERY); + + OLECHAR wString[64]={0}; + + if( pRXI.is() && pRXI->getAccessibleActionCount() >= 1) + { + Reference< XAccessibleKeyBinding > binding = pRXI->getAccessibleActionKeyBinding(0); + if( binding.is() ) + { + long nCount = binding->getAccessibleKeyBindingCount(); + if(nCount >= 1) + { + CAccAction::GetkeyBindingStrByXkeyBinding( binding->getAccessibleKeyBinding(0),wString ); + } + } + } + if(wString[0] == 0) + { + Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet(); + if(!pRrelationSet.is()) + { + return S_FALSE; + } + + long nRelCount = pRrelationSet->getRelationCount(); + + // Modified by Steve Yin, for SODC_1552 + if( /*nRelCount <= 0 &&*/ m_iRole == ROLE_SYSTEM_TEXT ) + { + VARIANT varParentRole; + VariantInit( &varParentRole ); + + m_pIParent->get_accRole(varChild, &varParentRole); + + if( m_pIParent && varParentRole.lVal == ROLE_SYSTEM_COMBOBOX ) // edit in comoboBox + { + m_pIParent->get_accKeyboardShortcut(varChild, pszKeyboardShortcut); + return S_OK; + } + } + + AccessibleRelation *paccRelation = NULL; + AccessibleRelation accRelation; + for(int i=0; i<nRelCount ; i++) + { + if( pRrelationSet->getRelation(i).RelationType == 6 ) + { + accRelation = pRrelationSet->getRelation(i); + paccRelation = &accRelation; + } + } + + if(paccRelation == NULL) + return S_FALSE; + + Sequence< Reference< XInterface > > xTargets = paccRelation->TargetSet; + Reference<XInterface> pRAcc = xTargets[0]; + + XAccessible* pXAcc = (XAccessible*)pRAcc.get(); + + Reference<XAccessibleContext> pRLebelContext = pXAcc->getAccessibleContext(); + if(!pRLebelContext.is()) + return S_FALSE; + + pRrelationSet = pRLebelContext->getAccessibleRelationSet(); + nRelCount = pRrelationSet->getRelationCount(); + + paccRelation = NULL; + for(int j=0; j<nRelCount ; j++) + { + if( pRrelationSet->getRelation(j).RelationType == 5 ) + { + accRelation = pRrelationSet->getRelation(j); + paccRelation = &accRelation; + } + } + + if(paccRelation) + { + xTargets = paccRelation->TargetSet; + pRAcc = xTargets[0]; + if(pUNOInterface != (XAccessible*)pRAcc.get()) + return S_FALSE; + } + + Reference<XAccessibleExtendedComponent> pRXIE(pRLebelContext,UNO_QUERY); + if(!pRXIE.is()) + return S_FALSE; + + ::rtl::OUString ouStr = pRXIE->getTitledBorderText(); + WCHAR key[2] = {NULL}; + GetMnemonicChar(ouStr, key); + if(key[0] != 0) + { + wcscat(wString, L"Alt+"); + wcscat(wString, key); + } + else + return S_FALSE; + } + + SAFE_SYSFREESTRING(*pszKeyboardShortcut); + *pszKeyboardShortcut = SysAllocString(wString); + + return S_OK; + } + else + { + return S_FALSE; + } + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + + return pChild->get_accKeyboardShortcut(varChild,pszKeyboardShortcut); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the current focused child to AT. +* @param pvarChild, [in,out] vt member of pvarChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::get_accFocus(VARIANT *pvarChild) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarChild == NULL) + { + return E_INVALIDARG; + } + if( m_dFocusChildID==UACC_NO_FOCUS ) + { + pvarChild->vt = VT_EMPTY;//no focus on the object and its children + return S_OK; + } + //if the descendant of current object has focus indicated by m_dFocusChildID, return the IDispatch of this focused object + else + { + IMAccessible* pIMAcc = NULL; + g_pAgent->GetIAccessibleFromResID(m_dFocusChildID,&pIMAcc); + pIMAcc->AddRef(); + pvarChild->vt = VT_DISPATCH; + pvarChild->pdispVal = pIMAcc; + + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the selection of the current COM object to AT. +* @param pvarChildren,[in,out] +* if selection num is 0,return VT_EMPTY for vt, +* if selection num is 1,return VT_I4 for vt,and child index for lVal +* if selection num >1,return VT_UNKNOWN for vt, and IEnumVariant* for punkVal +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::get_accSelection(VARIANT *pvarChildren) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarChildren == NULL) + { + return E_INVALIDARG; + } + switch(m_pEnumVar->GetCountOfElements()) + { + case 0: + pvarChildren->vt = VT_EMPTY; + break; + case 1: + VARIANT varTmp[1]; + ULONG count; + VariantInit(&varTmp[0]); + m_pEnumVar->Next(1,varTmp,&count); + if(count!=1) + return S_FALSE; + pvarChildren->vt = VT_I4; + pvarChildren->lVal = varTmp[0].lVal; + VariantClear(&varTmp[0]); + m_pEnumVar->Reset(); + break; + default: + pvarChildren->vt = VT_UNKNOWN; + m_pEnumVar->AddRef(); + pvarChildren->punkVal = m_pEnumVar; + break; + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the location of the current COM object self or its one child to AT. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param pxLeft, [in,out] use to return the x-coordination of the proper object. +* @param pyTop, [in,out] use to return the y-coordination of the proper object. +* @param pcxWidth, [in,out] use to return the x-coordination width of the proper object. +* @param pcyHeight, [in,out] use to return the y-coordination height of the proper object. +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pxLeft == NULL || pyTop == NULL || pcxWidth == NULL || pcyHeight == NULL) + { + return E_INVALIDARG; + } + + if(varChild.vt==VT_I4) + { + if(varChild.lVal==CHILDID_SELF) + { + + if(pUNOInterface) + { + Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + return S_FALSE; + Reference< XAccessibleComponent > pRComponent(pRContext,UNO_QUERY); + if( !pRComponent.is() ) + return S_FALSE; + + ::com::sun::star::awt::Point pCPoint = pRComponent->getLocationOnScreen(); + ::com::sun::star::awt::Size pCSize = pRComponent->getSize(); + *pxLeft = pCPoint.X; + *pyTop = pCPoint.Y; + *pcxWidth = pCSize.Width; + *pcyHeight = pCSize.Height; + return S_OK; + } + else + { + *pxLeft = m_sLocation.m_dLeft; + *pyTop = m_sLocation.m_dTop; + *pcxWidth = m_sLocation.m_dWidth; + *pcyHeight = m_sLocation.m_dHeight; + return S_OK; + } + } + + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Returns the current focused child to AT. +* @param navDir, the direction flag of the navigation. +* @param varStart, the start child id of this navigation action. +* @param pvarEndUpAt, [in,out] the end up child of this navigation action. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarEndUpAt == NULL) + { + return E_INVALIDARG; + } + HRESULT ret = E_FAIL; + switch (navDir) + { + case NAVDIR_FIRSTCHILD: + ret = GetFirstChild(varStart,pvarEndUpAt); + break; + case NAVDIR_LASTCHILD: + ret = GetLastChild(varStart,pvarEndUpAt); + break; + case NAVDIR_NEXT: + ret = GetNextSibling(varStart,pvarEndUpAt); + break; + case NAVDIR_PREVIOUS: + ret = GetPreSibling(varStart,pvarEndUpAt); + break; + case NAVDIR_DOWN://do not implement temporarily + break; + case NAVDIR_UP://do not implement temporarily + break; + case NAVDIR_LEFT://do not implement temporarily + break; + case NAVDIR_RIGHT://do not implement temporarily + break; + default: + break; + }; + return ret; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible::accHitTest(long xLeft, long yTop, VARIANT *pvarChild) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarChild == NULL) + { + return E_INVALIDARG; + } + long x, y, w, h; + VARIANT varSelf; + VariantInit(&varSelf); + varSelf.vt = VT_I4; + varSelf.lVal = CHILDID_SELF; + accLocation(&x,&y,&w,&h,varSelf); + if( (x < xLeft && (x + w) >xLeft) && (y < yTop && (y + h) >yTop) ) + { + int i, nCount; + pvarChild->vt = VT_EMPTY; + Reference< XAccessibleContext > pRContext = GetContextByXAcc(pUNOInterface); + nCount = pRContext->getAccessibleChildCount(); + if(nCount > 256) + return E_FAIL; + IMAccessible* child = NULL; + for( i = 0; i<nCount; i++) + { + + child = GetChildInterface(i + 1); + if(child && child->accHitTest(xLeft,yTop,pvarChild) == S_OK) + break; + } + + if(pvarChild->vt == VT_DISPATCH) + return S_OK; + + if( i < nCount) + { + pvarChild->vt = VT_DISPATCH; + pvarChild->pdispVal = child; + child->AddRef(); + } + else + { + pvarChild->vt = VT_I4; + pvarChild->lVal = CHILDID_SELF; + } + return S_OK; + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Get The other Interface from CMAccessible. +* @param guidService, must be IID_IAccessible here. +* @param riid, the IID interface . +* @return S_OK if successful and S_FALSE if failure. +*/ +STDMETHODIMP CMAccessible::QueryService(REFGUID guidService, REFIID riid, void** ppvObject) +{ + if( InlineIsEqualGUID(guidService, IID_IAccessible) ) + return QueryInterface(riid, ppvObject); + return S_FALSE; +} + +/** +* Set the accessible name of the current COM object self or its one child from UNO. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param szName, the name used to set the name of the proper object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::put_accName(VARIANT varChild, BSTR szName) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(varChild.vt==VT_I4) + { + if(varChild.lVal==CHILDID_SELF) + { + SAFE_SYSFREESTRING(m_pszName); + m_pszName=SysAllocString(szName); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->put_accName(varChild,szName); + } + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Set the accessible value of the current COM object self or its one child from UNO. +* @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID, +* the child ID specify child index from 0 to children count, 0 stands for object self. +* @param szValue, the value used to set the value of the proper object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::put_accValue(VARIANT varChild, BSTR szValue) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(varChild.vt==VT_I4) + { + if(varChild.lVal==CHILDID_SELF) + { + SysAllocString(m_pszValue); + m_pszValue=SysAllocString(szValue); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->put_accValue(varChild,szValue); + } + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Set the accessible name of the current COM object self from UNO. +* @param pszName, the name value used to set the name of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccName(const OLECHAR __RPC_FAR *pszName) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pszName == NULL) + { + return E_INVALIDARG; + } + + SAFE_SYSFREESTRING(m_pszName);//?? + m_pszName = SysAllocString(pszName); + if(m_pszName==NULL) + return E_FAIL; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Set the accessible role of the current COM object self from UNO. +* @param pRole, the role value used to set the role of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccRole(unsigned short pRole) +{ + m_iRole = pRole; + return S_OK; +} + +/** +* Add one state into the current state set for the current COM object from UNO. +* @param pXSate, the state used to set the name of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::DecreaseState(DWORD pXSate) +{ + m_dState &= (~pXSate); + return S_OK; +} + +/** +* Delete one state into the current state set for the current COM object from UNO. +* @param pXSate, the state used to set the name of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::IncreaseState(DWORD pXSate) +{ + m_dState |= pXSate; + return S_OK; +} + +/** +* Set state into the current state set for the current COM object from UNO. +* @param pXSate, the state used to set the name of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::SetState(DWORD pXSate) +{ + m_dState = pXSate; + return S_OK; +} + + + +/** +* Set the accessible description of the current COM object self from UNO. +* @param pszDescription, the name used to set the description of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccDescription(const OLECHAR __RPC_FAR *pszDescription) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pszDescription == NULL) + { + return E_INVALIDARG; + } + + SAFE_SYSFREESTRING(m_pszDescription); + m_pszDescription = SysAllocString(pszDescription); + + if(m_pszDescription==NULL) + return E_FAIL; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Set the accessible value of the current COM object self from UNO. +* @param pszAccValue, the name used to set the value of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccValue(const OLECHAR __RPC_FAR *pszAccValue) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pszAccValue == NULL) + { + return E_INVALIDARG; + } + SAFE_SYSFREESTRING(m_pszValue); + m_pszValue = SysAllocString(pszAccValue); + if(m_pszValue==NULL) + return E_FAIL; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Set the HWND value of the current COM object self from UNO. It should set the parent IAccessible +* Object through the method AccessibleObjectFromWindow(...). +* @param hwnd, the HWND used to set the value of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccWindowHandle(HWND hwnd) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + m_hwnd = hwnd; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Set accessible focus by specifying child ID +* @param dChildID, the child id identifies the focus child. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccFocus(long dChildID) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + + if(dChildID==CHILDID_SELF) + { + if(m_pIParent) + { + m_pIParent->Put_XAccFocus(m_dChildID); + } + } + else + { + m_dFocusChildID = dChildID; + //traverse all ancestors to set the focused child ID so that when the get_accFocus is called on + //any of the ancestors, this id can be used to get the IAccessible of focused object. + if(m_pIParent) + { + m_pIParent->Put_XAccFocus(dChildID); + } + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +*Set accessible object location for the current COM object +* @param sLocation, the location of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccLocation(const Location sLocation) +{ + + this->m_sLocation = sLocation; + return S_OK; +} + +/** +* Set accessible parent object for the current COM object if +* the current object is a child of some COM object +* @param pIParent, the parent of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccParent(IMAccessible __RPC_FAR *pIParent) +{ + this->m_pIParent = pIParent; + + if(pIParent) + m_pIParent->AddRef(); + + return S_OK; +} + +/** +* Set unique child id to COM +* @param dChildID, the id of the current object. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccChildID(long dChildID) +{ + + this->m_dChildID = dChildID; + return S_OK; +} + +/** +* Set AccObjectManagerAgent object pointer to COM +* @param pAgent, the AccObjectManagerAgent point. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::Put_XAccAgent(long pAgent) +{ + g_pAgent = (AccObjectManagerAgent*)pAgent; + return S_OK; +} + +/** +* When a UNO control disposing, it disposes its listeners, +* then notify AccObject in bridge management, then notify +* COM that the XAccessible is invalid,so set pUNOInterface as NULL +* @param isDestroy, true is it need to be destroyed. +* @return S_OK if successful and E_FAIL if failure. +*/ +STDMETHODIMP CMAccessible::NotifyDestroy(BOOL isDestroy) +{ + + m_isDestroy = isDestroy; + pUNOInterface = NULL; + return S_OK; +} + +/** +*private methods that help implement public functions +*/ + +/** +* Return child interface pointer by child ID,note: need to call AddRef() +* @param lChildID, specify child index,which AT(such as Inspect32) gives. +* @return IMAccessible*, pointer to the corresponding child object. +*/ +IMAccessible* CMAccessible::GetChildInterface(long dChildID)//for test +{ + + long dChildIndex = 0; + if(dChildID<0) + { + if(g_pAgent) + { + IMAccessible* pIMAcc = NULL; + g_pAgent->GetIAccessibleFromResID(dChildID,&pIMAcc); + return pIMAcc; + } + return NULL; + } + else + { + Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + return NULL; + + if(dChildID<1 || dChildID>pRContext->getAccessibleChildCount()) + return NULL; + + IAccessible* pChild = NULL; + Reference< XAccessible > pXChild = pRContext->getAccessibleChild(dChildID-1); + BOOL isGet = get_IAccessibleFromXAccessible((long)pXChild.get(),&pChild); + + if(!isGet) + { + g_pAgent->InsertAccObj(pXChild.get(),pUNOInterface,(long)m_hwnd); + isGet = get_IAccessibleFromXAccessible((long)pXChild.get(),&pChild); + } + + if(isGet) + { + IMAccessible* pIMAcc = (IMAccessible*)pChild; + return pIMAcc; + } + } + + return NULL; +} + +/** +* For List, tree and table,these roles belong to manage_decendant in UNO, +* need to process specifically when navigate +* @return BOOL, if it is decendantmanager, return true. +*/ +BOOL CMAccessible::IsDecendantManage() +{ + + return (m_iRole==ROLE_SYSTEM_LIST)||(m_iRole==ROLE_SYSTEM_OUTLINE)||(m_iRole==ROLE_SYSTEM_TABLE); +} + +/** +* for decendantmanager circumstance,provide child interface when navigate +* @param varCur, the current child. +* @param flags, the navigation direction. +* @return IMAccessible*, the child of the end up node. +*/ +IMAccessible* CMAccessible::GetNavigateChildForDM(VARIANT varCur, short flags) +{ + + XAccessibleContext* pXContext = GetContextByXAcc(pUNOInterface); + if(pXContext==NULL) + { + return NULL; + } + + int count = pXContext->getAccessibleChildCount(); + if(count<1) + { + return NULL; + } + + IMAccessible* pCurChild = NULL; + XAccessible* pChildXAcc = NULL; + Reference<XAccessible> pRChildXAcc; + XAccessibleContext* pChildContext = NULL; + int index = 0,delta=0; + switch(flags) + { + case DM_FIRSTCHILD: + pRChildXAcc = pXContext->getAccessibleChild(0); + break; + case DM_LASTCHILD: + pRChildXAcc = pXContext->getAccessibleChild(count-1); + break; + case DM_NEXTCHILD: + case DM_PREVCHILD: + pCurChild = GetChildInterface(varCur.lVal); + if(pCurChild==NULL) + { + return NULL; + } + pCurChild->GetUNOInterface((long*)&pChildXAcc); + if(pChildXAcc==NULL) + { + return NULL; + } + pChildContext = GetContextByXAcc(pChildXAcc); + if(pChildContext == NULL) + { + return NULL; + } + delta = (flags==DM_NEXTCHILD)?1:-1; + //currently, getAccessibleIndexInParent is error in UNO for + //some kind of List,such as ValueSet, the index will be less 1 than + //what should be, need to fix UNO code + index = pChildContext->getAccessibleIndexInParent()+delta; + if((index>=0)&&(index<=count-1)) + { + pRChildXAcc = pXContext->getAccessibleChild(index); + } + break; + default: + break; + } + + if(!pRChildXAcc.is()) + { + return NULL; + } + pChildXAcc = pRChildXAcc.get(); + g_pAgent->InsertAccObj(pChildXAcc,pUNOInterface); + return g_pAgent->GetIMAccByXAcc(pChildXAcc); +} + +/** +*the following 4 private methods are for accNavigate implementation +*/ + +/** +* Return first child for parent container, process differently according +* to whether it is decendant manage +* @param varStart, the start child id of this navigation action. +* @param pvarEndUpAt, [in,out] the end up child of this navigation action. +* @return S_OK if successful and E_FAIL if failure. +*/ +HRESULT CMAccessible::GetFirstChild(VARIANT varStart,VARIANT* pvarEndUpAt) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarEndUpAt == NULL) + { + return E_INVALIDARG; + } + if(varStart.vt != VT_I4) + { + pvarEndUpAt->vt = VT_EMPTY; + return E_INVALIDARG; + } + + pvarEndUpAt->pdispVal = GetNavigateChildForDM(varStart, DM_FIRSTCHILD); + if(pvarEndUpAt->pdispVal) + { + pvarEndUpAt->pdispVal->AddRef(); + pvarEndUpAt->vt = VT_DISPATCH; + return S_OK; + } + + pvarEndUpAt->vt = VT_EMPTY; + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Return last child for parent container, process differently according +* to whether it is decendant manage +* @param varStart, the start child id of this navigation action. +* @param pvarEndUpAt, [in,out] the end up child of this navigation action. +* @return S_OK if successful and E_FAIL if failure. +*/ +HRESULT CMAccessible::GetLastChild(VARIANT varStart,VARIANT* pvarEndUpAt) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarEndUpAt == NULL) + { + return E_INVALIDARG; + } + if(varStart.vt != VT_I4) + { + pvarEndUpAt->vt = VT_EMPTY; + return E_INVALIDARG; + } + + pvarEndUpAt->pdispVal = GetNavigateChildForDM(varStart, DM_LASTCHILD); + if(pvarEndUpAt->pdispVal) + { + pvarEndUpAt->pdispVal->AddRef(); + pvarEndUpAt->vt = VT_DISPATCH; + return S_OK; + } + pvarEndUpAt->vt = VT_EMPTY; + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** +* The method GetNextSibling is general, whatever it is decendant manage or not +* Get the next sibling object. +* @param varStart, the start child id of this navigation action. +* @param pvarEndUpAt, [in,out] the end up child of this navigation action. +* @return S_OK if successful and E_FAIL if failure. +*/ +HRESULT CMAccessible::GetNextSibling(VARIANT varStart,VARIANT* pvarEndUpAt) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(varStart.vt != VT_I4) + { + pvarEndUpAt->vt = VT_EMPTY; + return E_INVALIDARG; + } + + Reference< XAccessibleContext > pRContext = GetContextByXAcc(pUNOInterface); + if(pRContext.is()) + { + varStart.iVal = sal_Int16(pRContext->getAccessibleIndexInParent() + 2); + if(m_pIParent) + if( m_pIParent->get_accChild(varStart,&pvarEndUpAt->pdispVal) == S_OK) + { + pvarEndUpAt->vt = VT_DISPATCH; + return S_OK; + } + } + pvarEndUpAt->vt = VT_EMPTY; + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** +*the method GetPreSibling is general, whatever it is decendant manage or not +* @param varStart, the start child id of this navigation action. +* @param pvarEndUpAt, [in,out] the end up child of this navigation action. +* @return S_OK if successful and E_FAIL if failure. +*/ +HRESULT CMAccessible::GetPreSibling(VARIANT varStart,VARIANT* pvarEndUpAt) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pvarEndUpAt == NULL) + { + return E_INVALIDARG; + } + if(varStart.vt != VT_I4) + { + pvarEndUpAt->vt = VT_EMPTY; + return E_INVALIDARG; + } + + Reference< XAccessibleContext > pRContext = GetContextByXAcc(pUNOInterface); + if(pRContext.is()) + { + varStart.iVal = sal_Int16(pRContext->getAccessibleIndexInParent()); + if(m_pIParent && varStart.iVal > 0) + if( m_pIParent->get_accChild(varStart,&pvarEndUpAt->pdispVal) == S_OK) + { + pvarEndUpAt->vt = VT_DISPATCH; + return S_OK; + } + } + pvarEndUpAt->vt = VT_EMPTY; + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +/** +* For IAccessible2 implementation methods +*/ +STDMETHODIMP CMAccessible::get_nRelations( long __RPC_FAR *nRelations) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(nRelations == NULL) + { + return E_INVALIDARG; + } + + *nRelations = 0; + + if( !pRContext.is() ) + return E_FAIL; + Reference<XAccessibleRelationSet> pRrelationSet = pRContext.get()->getAccessibleRelationSet(); + if(!pRrelationSet.is()) + { + *nRelations = 0; + return S_OK; + } + + *nRelations = pRrelationSet->getRelationCount(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible::get_relation( long relationIndex, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(relation == NULL) + { + return E_INVALIDARG; + } + + if( !pRContext.is() ) + return E_FAIL; + + + long nMax = 0; + long nReal = 0; + get_nRelations(&nMax); + + *relation = (IAccessibleRelation*)::CoTaskMemAlloc(sizeof(IAccessibleRelation)); + + // #CHECK Memory Allocation# + if(*relation == NULL) + { + return E_FAIL; + } + + if( relationIndex < nMax ) + { + + + Reference<XAccessibleRelationSet> pRrelationSet = pRContext.get()->getAccessibleRelationSet(); + if(!pRrelationSet.is()) + { + + return E_FAIL; + } + + IAccessibleRelation* pRelation = NULL; + ActivateActContext(); + HRESULT hr = CoCreateInstance( CLSID_AccRelation, NULL, CLSCTX_SERVER , + IID_IAccessibleRelation, + (void **)&pRelation); + DeactivateActContext(); + if(SUCCEEDED(hr)) + { + IUNOXWrapper* wrapper = NULL; + hr = pRelation->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper); + if(SUCCEEDED(hr)) + { + AccessibleRelation accRelation = pRrelationSet->getRelation(relationIndex); + wrapper->put_XSubInterface((long)&accRelation); + wrapper->Release(); + *relation = pRelation; + return S_OK; + } + + } + } + + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible::get_relations( long, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation, long __RPC_FAR *nRelations) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(relation == NULL || nRelations == NULL) + { + return E_INVALIDARG; + } + // #CHECK XInterface# + + if( !pRContext.is() ) + return E_FAIL; + + Reference<XAccessibleRelationSet> pRrelationSet = pRContext.get()->getAccessibleRelationSet(); + if(!pRrelationSet.is()) + { + *nRelations = 0; + return S_OK; + } + + long nCount = pRrelationSet->getRelationCount(); + + *relation = (IAccessibleRelation*)::CoTaskMemAlloc(nCount*sizeof(IAccessibleRelation)); + + // #CHECK Memory Allocation# + if(*relation == NULL) + { + return E_FAIL; + } + + for(int i=0; i<nCount ; i++) + { + IAccessibleRelation* pRelation = NULL; + ActivateActContext(); + HRESULT hr = CoCreateInstance( CLSID_AccRelation, NULL, CLSCTX_SERVER , + IID_IAccessibleRelation, + (void **)&pRelation); + DeactivateActContext(); + if(SUCCEEDED(hr)) + { + IUNOXWrapper* wrapper = NULL; + hr = pRelation->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper); + if(SUCCEEDED(hr)) + { + AccessibleRelation accRelation = pRrelationSet->getRelation(i); + wrapper->put_XSubInterface((long)&accRelation); + wrapper->Release(); + } + (relation)[i] = pRelation; + } + } + + *nRelations = nCount; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible::role(long __RPC_FAR *role) +{ + ENTER_PROTECTED_BLOCK + + (*role) = m_iRole; + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + + +STDMETHODIMP CMAccessible:: get_nActions(long __RPC_FAR *nActions) +{ + + try + { + ISDESTROY() + // #CHECK# + if(nActions == NULL) + { + return E_INVALIDARG; + } + *nActions = 0L; + IAccessibleAction* pAcc = NULL; + HRESULT hr = QueryInterface(IID_IAccessibleAction, (void**)&pAcc); + if( hr == S_OK ) + { + pAcc->nActions(nActions); + pAcc->Release(); + } + + return S_OK; + } + catch(...) + { + *nActions = 0L; + return S_OK; + } +} + + +STDMETHODIMP CMAccessible:: scrollToPoint(enum IA2CoordinateType, long, long) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + return E_NOTIMPL; + LEAVE_PROTECTED_BLOCK + +} +STDMETHODIMP CMAccessible:: scrollTo(enum IA2ScrollType) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + +static XAccessible* getTheParentOfMember(XAccessible* pXAcc) +{ + // #CHECK# + if(pXAcc == NULL) + { + return NULL; + } + Reference<XAccessibleContext> pRContext = pXAcc->getAccessibleContext(); + Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet(); + long nRelations = pRrelationSet->getRelationCount(); + for(int i=0 ; i<nRelations ; i++) + { + AccessibleRelation accRelation = pRrelationSet->getRelation(i); + if(accRelation.RelationType == 7) + { + Sequence< Reference< XInterface > > xTargets = accRelation.TargetSet; + return (XAccessible*)xTargets[0].get(); + } + } + return NULL; +} + +STDMETHODIMP CMAccessible:: get_groupPosition(long __RPC_FAR *groupLevel,long __RPC_FAR *similarItemsInGroup,long __RPC_FAR *positionInGroup) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(groupLevel == NULL || similarItemsInGroup == NULL || positionInGroup == NULL) + { + return E_INVALIDARG; + } + + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if(!pRContext.is()) + return E_FAIL; + long Role = pRContext->getAccessibleRole(); + + *groupLevel = 0; + *similarItemsInGroup = 0; + *positionInGroup = 0; + + if (Role != AccessibleRole::DOCUMENT) + { + Reference< XAccessibleGroupPosition > xGroupPosition( pRContext, UNO_QUERY ); + if ( xGroupPosition.is() ) + { + Sequence< sal_Int32 > rSeq = xGroupPosition->getGroupPosition( makeAny( pRContext ) ); + sal_Int32* pSeq = rSeq.getArray(); + if ( pSeq ) + { + *groupLevel = pSeq[0]; + *similarItemsInGroup = pSeq[1]; + *positionInGroup = pSeq[2]; + return S_OK; + } + return S_OK; + } + } + + Reference< XAccessible> pParentAcc = pRContext->getAccessibleParent(); + if( !pParentAcc.is() ) + { + return S_OK; + } + + Reference<XAccessibleContext> pRParentContext = pParentAcc->getAccessibleContext(); + + int level = 0; + int index = 0; + int number = 0; + + if( Role == RADIO_BUTTON ) + { + Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet(); + long nRel = pRrelationSet->getRelationCount(); + for(int i=0 ; i<nRel ; i++) + { + AccessibleRelation accRelation = pRrelationSet->getRelation(i); + if(accRelation.RelationType == 7) + { + Sequence< Reference< XInterface > > xTargets = accRelation.TargetSet; + int nCount = xTargets.getLength(); + + Reference<XInterface> pRAcc = xTargets[0]; + for(int j=0; j<pRParentContext->getAccessibleChildCount(); j++) + { + if( getTheParentOfMember(pRParentContext->getAccessibleChild(j).get()) + == (XAccessible*)pRAcc.get() && + pRParentContext->getAccessibleChild(j)->getAccessibleContext()->getAccessibleRole() == RADIO_BUTTON) + number++; + if(pRParentContext->getAccessibleChild(j).get() == pUNOInterface) + index = number; + } + } + } + *groupLevel = 1; + *similarItemsInGroup = number; + *positionInGroup = index; + return S_OK; + } + + else if ( COMBO_BOX == Role ) + { + *groupLevel = 1; + *similarItemsInGroup = 0; + *positionInGroup = -1; + + long nCount = pRContext->getAccessibleChildCount(); + if( 2 != nCount) + { + return S_OK; + } + Reference<XAccessible> xList=pRContext->getAccessibleChild(1); + if (!xList.is()) + { + return S_OK; + } + Reference<XAccessibleContext> xListContext(xList,UNO_QUERY); + if (!xListContext.is()) + { + return S_OK; + } + Reference<XAccessibleSelection> xListSel(xList,UNO_QUERY); + if (!xListSel.is()) + { + return S_OK; + } + *similarItemsInGroup = xListContext->getAccessibleChildCount(); + if (*similarItemsInGroup > 0 ) + { + try + { + Reference<XAccessible> xChild = xListSel->getSelectedAccessibleChild(0); + if (xChild.is()) + { + Reference<XAccessibleContext> xChildContext(xChild,UNO_QUERY); + if (xChildContext.is()) + { + *positionInGroup=xChildContext->getAccessibleIndexInParent() + 1 ; + return S_OK; + } + } + } + catch(...) + {} + } + return S_OK; + } + else if ( PAGE_TAB == Role ) + { + *groupLevel = 1; + *similarItemsInGroup = pRParentContext->getAccessibleChildCount(); + + if (*similarItemsInGroup > 0 ) + { + *positionInGroup=pRContext->getAccessibleIndexInParent() + 1 ; + } + else + { + *positionInGroup = -1; + } + return S_OK; + } + + + BOOL isFound = FALSE; + while( pParentAcc.is() && !isFound) + { + level++; + pRParentContext = pParentAcc->getAccessibleContext(); + Role = pRParentContext->getAccessibleRole(); + if( (Role == TREE) || (Role == LIST) ) + isFound = TRUE; + pParentAcc = pRParentContext->getAccessibleParent(); + } + + if( isFound ) + { + Reference< XAccessible> pTempAcc = pRContext->getAccessibleParent(); + pRParentContext = pTempAcc->getAccessibleContext(); + *groupLevel = level; + *similarItemsInGroup = pRParentContext->getAccessibleChildCount(); + *positionInGroup = pRContext->getAccessibleIndexInParent() + 1; + } + else + { + *groupLevel = 0; + *similarItemsInGroup = 0; + *positionInGroup = 0; + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible:: get_extendedStates( long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + + +STDMETHODIMP CMAccessible:: get_uniqueID(long __RPC_FAR *uniqueID) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(uniqueID == NULL) + { + return E_INVALIDARG; + } + *uniqueID = m_dChildID; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible:: get_windowHandle(HWND __RPC_FAR *windowHandle) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(windowHandle == NULL) + { + return E_INVALIDARG; + } + + HWND nHwnd = m_hwnd; + IAccessible* pParent = m_pIParent; + CMAccessible* pChild = this; + while((nHwnd==0) && pParent) + { + pChild = (CMAccessible*)pParent; + if(pChild) + { + pParent = (IAccessible*)pChild->m_pIParent; + nHwnd = (HWND)pChild->m_hwnd; + } + else + pParent = NULL; + } + + *windowHandle = nHwnd; + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Get XAccessibleContext directly from UNO by the stored XAccessible pointer +* @param pXAcc, UNO XAccessible object point. +* @return XAccessibleContext*, the context of the pXAcc. +*/ +XAccessibleContext* CMAccessible::GetContextByXAcc( XAccessible* pXAcc ) +{ + Reference< XAccessibleContext > pRContext; + if( pXAcc == NULL) + return NULL; + + pRContext = pXAcc->getAccessibleContext(); + if( !pRContext.is() ) + return NULL; + return pRContext.get(); +} + +/** +* Return the member variable m_pXAccessibleSelection, instead of +* get XAccessibleSelection according to XAccessibleContext because if so,it will +* depend on the UNO implementation code,so when COM is created, put XAccessibleSelection +* by bridge management system +* @return XAccessibleSelection*, the selection of the current object. +*/ +Reference< XAccessibleSelection > CMAccessible::GetSelection() +{ + if( pUNOInterface == NULL ) + return NULL; + Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext(); + if(pRContext.is()) + { + Reference< XAccessibleSelection > pRSelection(pRContext,UNO_QUERY); + return pRSelection; + } + return NULL; +} + +/** +* Select one XAccessible item, for accSelect implementation +* @param pItem, the item should be selected. +* @return S_OK if successful. +*/ +HRESULT CMAccessible::SelectChild(XAccessible* pItem) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + XAccessibleContext* pParentContext = GetContextByXAcc( pUNOInterface ); + XAccessibleContext* pContext = GetContextByXAcc( pItem ); + if( pParentContext == NULL || pContext == NULL ) + return E_FAIL; + + Reference< XAccessibleSelection > pRSelection = GetSelection(); + if( !pRSelection.is() ) + return E_FAIL; + long Index = pContext->getAccessibleIndexInParent(); + pRSelection->selectAccessibleChild( Index ); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Deselect one XAccessible item, for accSelect implimentation +* @param pItem, the item should be deselected. +* @return S_OK if successful. +*/ +HRESULT CMAccessible::DeSelectChild(XAccessible* pItem) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + XAccessibleContext* pParentContext = GetContextByXAcc( pUNOInterface ); + ; + XAccessibleContext* pContext = GetContextByXAcc( pItem ); + if( pParentContext == NULL || pContext == NULL ) + return E_INVALIDARG; + + Reference< XAccessibleSelection > pRSelection = GetSelection(); + if( !pRSelection.is() ) + return E_FAIL; + long Index = pContext->getAccessibleIndexInParent(); + pRSelection->deselectAccessibleChild( Index ); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Select multiple XAccessible items,for implementation of accSelect +* @param pItem, the items should be selected. +* @param size, the size of the items. +* @return S_OK if successful. +*/ +HRESULT CMAccessible::SelectMutipleChidren( XAccessible** pItem,int size ) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pItem == NULL) + { + return E_INVALIDARG; + } + for(int index = 0;index < size;index++) + { + SelectChild( pItem[index] ); + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Deselect multiple XAccessible items,for implementation of accSelect +* @param pItem, the items should be selected. +* @param size, the size of the items. +* @return S_OK if successful. +*/ +HRESULT CMAccessible::DeSelectMutipleChildren( XAccessible** pItem,int size ) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pItem == NULL) + { + return E_INVALIDARG; + } + for(int index = 0;index < size;index++) + { + DeSelectChild( pItem[index] ); + } + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* When COM is created, UNO set XAccessible pointer to it +* in order to COM can operate UNO information +* @param pXAcc, the XAccessible object of current object. +* @return S_OK if successful. +*/ +STDMETHODIMP CMAccessible::SetXAccessible(long pXAcc) +{ + pUNOInterface = (XAccessible*)pXAcc; + pRef = pUNOInterface; + m_pEnumVar->PutSelection(/*XAccessibleSelection*/(long)pUNOInterface); + + pRContext = pUNOInterface->getAccessibleContext(); + pRContextInterface = (XAccessibleContext*)pRContext.is(); + + return S_OK; +} + +/** +* accSelect method has many optional flags, needs to process comprehensively +* Mozilla and Microsoft do not implement SELFLAG_EXTENDSELECTION flag. +* The implementation of this flag is a little trouble-shooting,so we also +* do not implement it now +* @param flagsSelect, the selection flag of the select action. +* @param varChild, the child object pointer of current action. +* @return S_OK if successful. +*/ +STDMETHODIMP CMAccessible::accSelect(long flagsSelect, VARIANT varChild) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + if( (flagsSelect&SELFLAG_ADDSELECTION) && + (SELFLAG_REMOVESELECTION&flagsSelect) ) + return E_INVALIDARG; + + if ( (flagsSelect&SELFLAG_TAKESELECTION) && + ( + (flagsSelect&SELFLAG_ADDSELECTION) || + (flagsSelect&SELFLAG_REMOVESELECTION) || + (flagsSelect&SELFLAG_EXTENDSELECTION ) + ) + ) + return E_INVALIDARG; + + if ( varChild.vt != VT_I4 ) + return E_INVALIDARG; + + IMAccessible* pSelectAcc; + if( varChild.lVal == CHILDID_SELF ) + { + pSelectAcc = this; + pSelectAcc->AddRef(); + } + else + { + pSelectAcc = GetChildInterface(varChild.lVal); + } + + if( pSelectAcc == NULL ) + return E_INVALIDARG; + + if( flagsSelect&SELFLAG_TAKEFOCUS ) + { + long pTempUNO = 0; + pSelectAcc->GetUNOInterface( &pTempUNO); + + if( pTempUNO == NULL ) + return NULL; + + Reference< XAccessibleContext > pRContext = ( (XAccessible*)pTempUNO)->getAccessibleContext(); + Reference< XAccessibleComponent > pRComponent(pRContext,UNO_QUERY); + Reference< XAccessible > pRParentXAcc = pRContext->getAccessibleParent(); + Reference< XAccessibleContext > pRParentContext = pRParentXAcc->getAccessibleContext(); + Reference< XAccessibleComponent > pRParentComponent(pRParentContext,UNO_QUERY); + Reference< XAccessibleSelection > pRParentSelection(pRParentContext,UNO_QUERY); + + + pRComponent->grabFocus(); + + if( flagsSelect & SELFLAG_TAKESELECTION ) + { + pRParentSelection->clearAccessibleSelection(); + pRParentSelection->selectAccessibleChild( pRContext->getAccessibleIndexInParent() ); + } + + if( flagsSelect & SELFLAG_ADDSELECTION ) + { + pRParentSelection->selectAccessibleChild( pRContext->getAccessibleIndexInParent() ); + } + + if( flagsSelect & SELFLAG_REMOVESELECTION ) + { + pRParentSelection->deselectAccessibleChild( pRContext->getAccessibleIndexInParent() ); + } + + if( flagsSelect & SELFLAG_EXTENDSELECTION ) + { + long indexInParrent = pRContext->getAccessibleIndexInParent(); + + if( pRParentSelection->isAccessibleChildSelected( indexInParrent + 1 ) || + pRParentSelection->isAccessibleChildSelected( indexInParrent - 1 ) ) + { + pRParentSelection->selectAccessibleChild( indexInParrent ); + } + } + + } + + pSelectAcc->Release(); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +/** +* Return XAccessible interface pointer when needed +* @param pXAcc, [in, out] the Uno interface of the current object. +* @return S_OK if successful. +*/ +STDMETHODIMP CMAccessible::GetUNOInterface(long* pXAcc) +{ + // #CHECK# + if(pXAcc == NULL) + return E_INVALIDARG; + + *pXAcc = (long)pUNOInterface; + return S_OK; +} + +/** +* Helper method for Implementation of get_accDefaultAction +* @param pAction, the default action point of the current object. +* @return S_OK if successful. +*/ +STDMETHODIMP CMAccessible::SetDefaultAction(long pAction) +{ + m_pXAction = (XAccessibleAction*)pAction; + return S_OK; +} + +/** +* This method is called when AT open some UI elements initially +* the UI element takes the default action defined here +* @param varChild, the child id of the defaultaction. +* @param pszDefaultAction,[in/out] the description of the current action. +* @return S_OK if successful. +*/ +HRESULT STDMETHODCALLTYPE CMAccessible::get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(pszDefaultAction == NULL) + { + return E_INVALIDARG; + } + if(varChild.vt==VT_I4) + { + if(varChild.lVal==CHILDID_SELF) + { + if( m_pXAction == NULL ) + return DISP_E_MEMBERNOTFOUND; + SAFE_SYSFREESTRING(*pszDefaultAction); + *pszDefaultAction = SysAllocString(m_pszActionDescription); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->get_accDefaultAction(varChild,pszDefaultAction); + } + return S_FALSE; + + LEAVE_PROTECTED_BLOCK +} + +/** +* AT call this method to operate application +* @param varChild, the child id of the action object. +* @return S_OK if successful. +*/ +HRESULT STDMETHODCALLTYPE CMAccessible::accDoDefaultAction(VARIANT varChild) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if( varChild.vt != VT_I4 ) + return E_INVALIDARG; + if( m_pXAction == NULL ) + return E_FAIL; + if( m_pXAction->getAccessibleActionCount() == 0 ) + return E_FAIL; + + if(varChild.lVal==CHILDID_SELF) + { + if(m_pXAction->getAccessibleActionCount() > 0) + m_pXAction->doAccessibleAction(0); + return S_OK; + } + + long lVal = varChild.lVal; + varChild.lVal = CHILDID_SELF; + IMAccessible *pChild = this->GetChildInterface(lVal); + if(!pChild) + return E_FAIL; + return pChild->accDoDefaultAction( varChild ); + + LEAVE_PROTECTED_BLOCK +} + +/** +* UNO set description information for action to COM. +* @param szAction, the action description of the current object. +* @return S_OK if successful. +*/ +STDMETHODIMP CMAccessible::Put_ActionDescription( const OLECHAR* szAction) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(szAction == NULL) + { + return E_INVALIDARG; + } + SAFE_SYSFREESTRING(m_pszActionDescription ); + m_pszActionDescription = SysAllocString( szAction ); + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +BOOL CMAccessible::GetXInterfaceFromXAccessible(XAccessible* pXAcc, XInterface** ppXI, int index) +{ + Reference< XAccessibleContext > pRContext; + + switch(index) + { + case XI_COMPONENT: + QUERYXINTERFACE(AccessibleComponent) + break; + case XI_TEXT: + QUERYXINTERFACE(AccessibleText) + break; + case XI_EDITABLETEXT: + QUERYXINTERFACE(AccessibleEditableText) + break; + case XI_TABLE: + QUERYXINTERFACE(AccessibleTable) + break; + case XI_SELECTION: + QUERYXINTERFACE(AccessibleSelection) + break; + case XI_EXTENDEDCOMP: + QUERYXINTERFACE(AccessibleExtendedComponent) + break; + case XI_KEYBINDING: + QUERYXINTERFACE(AccessibleKeyBinding) + break; + case XI_ACTION: + QUERYXINTERFACE(AccessibleAction) + break; + case XI_VALUE: + QUERYXINTERFACE(AccessibleValue) + break; + case XI_HYPERTEXT: + QUERYXINTERFACE(AccessibleHypertext) + break; + case XI_HYPERLINK: + QUERYXINTERFACE(AccessibleHyperlink) + break; + case XI_IMAGE: + QUERYXINTERFACE(AccessibleImage) + break; + default: + break; + } + + return FALSE; +} + +HRESULT WINAPI CMAccessible::SmartQI(void* pv, REFIID iid, void** ppvObject) +{ + ENTER_PROTECTED_BLOCK + ISDESTROY() + if( ImplIsEqualGUID(iid,IID_IAccIdentity) || + ImplIsEqualGUID(iid,IID_IStdMarshalInfo) || + ImplIsEqualGUID(iid,IID_IMarshal) || + ImplIsEqualGUID(iid,IID_IExternalConnection)|| + ImplIsEqualGUID(iid,IID_IOleWindow)) + return E_FAIL; + + + _UNO_AGGMAP_ENTRY* pMap = _GetAggEntries(); + while(pMap && pMap->piid) + { + if(ImplIsEqualGUID(iid, *pMap->piid)) + { + XInterface* pXI = NULL; + BOOL bFound = GetXInterfaceFromXAccessible(pUNOInterface,&pXI,pMap->XIFIndex); + if(!bFound) + { + return E_FAIL; + } + + XGUIDToComObjHash::iterator pIndTemp = m_containedObjects.find( iid ); + if ( pIndTemp != m_containedObjects.end() ) + { + return pIndTemp->second.p->QueryInterface( iid, ppvObject ); + } + else + { + ActivateActContext(); + HRESULT hr = pMap->pfnCreateInstance(pv, iid, ppvObject); + DeactivateActContext(); + if(hr == S_OK) + { + m_containedObjects.insert(XGUIDToComObjHash::value_type(*pMap->piid,(IUnknown*)*ppvObject)); + IUNOXWrapper* wrapper = NULL; + ((IUnknown*)*ppvObject)->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper); + if(wrapper) + { + wrapper->put_XInterface((long)pUNOInterface); + wrapper->Release(); + } + return S_OK; + } + } + return E_FAIL; + } + pMap++; + } + return E_FAIL; + + LEAVE_PROTECTED_BLOCK +} + +BOOL CMAccessible::get_IAccessibleFromXAccessible(long pXAcc, IAccessible **ppIA) +{ + + ENTER_PROTECTED_BLOCK + + // #CHECK# + if(ppIA == NULL) + { + return E_INVALIDARG; + } + BOOL isGet = FALSE; + if(g_pAgent) + isGet = g_pAgent->GetIAccessibleFromXAccessible((XAccessible*)pXAcc,ppIA); + + if(isGet) + return TRUE; + else + return FALSE; + + LEAVE_PROTECTED_BLOCK +} + +void CMAccessible::get_OLECHARFromAny(Any& pAny, OLECHAR* pChar) +{ + // #CHECK# + if(pChar == NULL) + return; + + switch(pAny.getValueTypeClass()) + { + case TypeClass_CHAR: + { + sal_Int8 val; + pAny >>= val; + swprintf( pChar, L"%d", val); + break; + } + case TypeClass_BOOLEAN: + { + sal_Bool val; + pAny >>= val; + swprintf( pChar, L"%d", val); + break; + } + case TypeClass_BYTE: + { + sal_Int8 val; + pAny >>= val; + swprintf( pChar, L"%d", val); + break; + } + case TypeClass_SHORT: + { + SHORT val; + pAny >>= val; + swprintf( pChar, L"%d", val); + break; + } + case TypeClass_UNSIGNED_SHORT: + { + USHORT val; + pAny >>= val; + swprintf( pChar, L"%d", val); + break; + } + case TypeClass_LONG: + { + LONG val; + pAny >>= val; + swprintf( pChar, L"%ld", val); + break; + } + case TypeClass_UNSIGNED_LONG: + { + ULONG val; + pAny >>= val; + swprintf( pChar, L"%ld", val); + break; + } + case TypeClass_FLOAT: + { + FLOAT val; + pAny >>= val; + swprintf( pChar, L"%.3f", val); + break; + } + case TypeClass_DOUBLE: + { + DOUBLE val; + pAny >>= val; + swprintf( pChar, L"%.6lf", val); + break; + } + case TypeClass_STRING: + { + ::rtl::OUString val; + pAny >>= val; + wcscpy(pChar, val.getStr()); + break; + } + case TypeClass_SEQUENCE: + { + if(pAny.getValueType() == getCppuType( (Sequence< ::rtl::OUString > *)0 ) ) + { + Sequence < ::rtl::OUString > val; + pAny >>= val; + + ::rtl::OUString pString; + + int count = val.getLength(); + + for( int iIndex = 0;iIndex < count;iIndex++ ) + { + pString += val[iIndex]; + } + wcscpy(pChar, pString.getStr()); + } + else if (pAny.getValueType() == getCppuType( (Sequence< ::com::sun::star::style::TabStop >* )0 ) ) + { + Sequence < ::com::sun::star::style::TabStop > val; + pAny >>= val; + int count = val.getLength(); + + for( int iIndex = 0;iIndex < count;iIndex++ ) + { + OLECHAR pAttrs[512] = {NULL}; + + OLECHAR pAttrsPosition[512] = {NULL}; + OLECHAR pAttrsDescimalChar[512] = {NULL}; + OLECHAR pAttrsFillChar[512] = {NULL}; + + ::com::sun::star::style::TabStop sigleVal = val[iIndex]; + + swprintf( pAttrsPosition, L"Position=%ld,TabAlign=%ld", + sigleVal.Position, sigleVal.Alignment); + + if(sigleVal.DecimalChar==';' || sigleVal.DecimalChar == ':' || sigleVal.DecimalChar == ',' || + sigleVal.DecimalChar == '=' || sigleVal.DecimalChar == '\\') + swprintf( pAttrsDescimalChar, L"DecimalChar=\\%c",sigleVal.DecimalChar); + else + swprintf( pAttrsDescimalChar, L"DecimalChar=%c",sigleVal.DecimalChar); + + if(sigleVal.FillChar==';' || sigleVal.FillChar == ':' || sigleVal.FillChar == ',' || + sigleVal.FillChar == '=' || sigleVal.FillChar == '\\') + swprintf( pAttrsFillChar, L"FillChar=\\%c",sigleVal.FillChar); + else + swprintf( pAttrsFillChar, L"FillChar=%c",sigleVal.FillChar); + + swprintf( pAttrs, L"%s,%s,%s,",pAttrsPosition,pAttrsDescimalChar,pAttrsFillChar); + + wcscat(pChar,pAttrs); + } + } + break; + } + case TypeClass_ENUM: + { + if (pAny.getValueType() == getCppuType( (::com::sun::star::awt::FontSlant* )0 ) ) + { + com::sun::star::awt::FontSlant val; + pAny >>= val; + swprintf( pChar, L"%d", val); + } + } + case TypeClass_STRUCT: + { + if (pAny.getValueType() == getCppuType( (::com::sun::star::style::LineSpacing* )0 ) ) + { + com::sun::star::style::LineSpacing val; + pAny >>= val; + swprintf( pChar, L"Mode=%ld,Height=%ld,", val.Mode, val.Height); + } + else if (pAny.getValueType() == getCppuType( (com::sun::star::accessibility::TextSegment *)0 ) ) + { + com::sun::star::accessibility::TextSegment val; + pAny >>= val; + ::rtl::OUString realVal(val.SegmentText); + wcscpy(pChar, realVal.getStr()); + } + break; + } + case TypeClass_VOID: + case TypeClass_HYPER: + case TypeClass_UNSIGNED_HYPER: + case TypeClass_TYPE: + case TypeClass_ANY: + case TypeClass_TYPEDEF: + case TypeClass_UNION: + case TypeClass_EXCEPTION: + case TypeClass_ARRAY: + case TypeClass_INTERFACE: + case TypeClass_SERVICE: + case TypeClass_MODULE: + case TypeClass_INTERFACE_METHOD: + case TypeClass_INTERFACE_ATTRIBUTE: + case TypeClass_UNKNOWN: + case TypeClass_PROPERTY: + case TypeClass_CONSTANT: + case TypeClass_CONSTANTS: + case TypeClass_SINGLETON: + case TypeClass_MAKE_FIXED_SIZE: + break; + default: + break; + } +} + +void CMAccessible::get_OLECHAR4Numbering(const Any& pAny, short numberingLevel,const OUString& numberingPrefix,OLECHAR* pChar) +{ + if(pChar == NULL) + return; + Reference< ::com::sun::star::container::XIndexReplace > pXIndex; + if((pAny>>=pXIndex) && (numberingLevel !=-1))//numbering level is -1,means invalid value + { + Any aAny = pXIndex->getByIndex(numberingLevel); + Sequence< ::com::sun::star::beans::PropertyValue > aProps; + aAny >>= aProps; + const ::com::sun::star::beans::PropertyValue* pPropArray = aProps.getConstArray(); + sal_Int32 nCount = aProps.getLength(); + swprintf(pChar,L"Numbering:NumberingLevel=%d,",numberingLevel); + for( sal_Int32 i=0; i<nCount; i++ ) + { + ::com::sun::star::beans::PropertyValue rProp = pPropArray[i]; + if( (rProp.Name.compareTo(OUString::createFromAscii("BulletChar"))==0)|| + (rProp.Name.compareTo(OUString::createFromAscii("GraphicURL"))==0)|| + (rProp.Name.compareTo(OUString::createFromAscii("NumberingType"))==0)) + { + OLECHAR propStr[512] = {NULL}; + swprintf(propStr,L"%s=",rProp.Name.getStr()); + OLECHAR pTemp[256] = {NULL}; + CMAccessible::get_OLECHARFromAny(rProp.Value,pTemp); + if(rProp.Name.compareTo(OUString::createFromAscii("GraphicURL"))==0) + { + OLECHAR* pOccur = wcschr(pTemp,':'); + if(pOccur) + *pOccur = '.'; + } + wcscat(propStr,pTemp); + wcscat(pChar,propStr); + wcscat(pChar,L","); + + if(rProp.Name.compareTo(OUString::createFromAscii("NumberingType"))==0) + { + if(numberingPrefix.getLength()!=0) + { + swprintf(pTemp,L"NumberingPrefix=%s,",numberingPrefix.getStr()); + wcscat(pChar,pTemp); + } + } + } + } + } + + //Because now have three types numbering level: + //1.real numbering list,numbering level>=0 and numbering Rule !=NULL; + //2.common paragraph, numbering level >=0, and numbering Rule == NULL; + //3.TOC paragraph, numbering level >0, and numbering Rule ==NULL; + // IAText:numberinglevel base on 0, but TOC's level base on 1, + // so NumberingLevel value will be decreased 1 in bridge code. + else if(numberingLevel >0) + { + swprintf(pChar,L"Numbering:NumberingLevel=%d,NumberingType=4,NumberingPrefix=,",numberingLevel-1); + } + else + { + swprintf(pChar,L"Numbering:"); + } +} + +void CMAccessible::ConvertAnyToVariant(const ::com::sun::star::uno::Any &rAnyVal, VARIANT *pvData) +{ + if(rAnyVal.hasValue()) + { + // Clear VARIANT variable. + VariantClear(pvData); + + // Set value according to value type. + switch(rAnyVal.getValueTypeClass()) + { + case TypeClass_CHAR: + pvData->vt = VT_UI1; + memcpy(&pvData->bVal, rAnyVal.getValue(), sizeof(sal_Char)); + break; + + case TypeClass_BOOLEAN: + pvData->vt = VT_BOOL; + memcpy(&pvData->boolVal, rAnyVal.getValue(), sizeof(sal_Bool)); + break; + + case TypeClass_BYTE: + pvData->vt = VT_UI1; + memcpy(&pvData->bVal, rAnyVal.getValue(), sizeof(sal_Int8)); + break; + + case TypeClass_SHORT: + pvData->vt = VT_I2; + memcpy(&pvData->iVal, rAnyVal.getValue(), sizeof(sal_Int16)); + break; + + case TypeClass_UNSIGNED_SHORT: + pvData->vt = VT_I2; + memcpy(&pvData->iVal, rAnyVal.getValue(), sizeof(sal_uInt16)); + break; + + case TypeClass_LONG: + pvData->vt = VT_I4; + memcpy(&pvData->lVal, rAnyVal.getValue(), sizeof(sal_Int32)); + break; + + case TypeClass_UNSIGNED_LONG: + pvData->vt = VT_I4; + memcpy(&pvData->lVal, rAnyVal.getValue(), sizeof(sal_uInt32)); + break; + + case TypeClass_FLOAT: + pvData->vt = VT_R4; + memcpy(&pvData->fltVal, rAnyVal.getValue(), sizeof(float)); + break; + + case TypeClass_DOUBLE: + pvData->vt = VT_R8; + memcpy(&pvData->dblVal, rAnyVal.getValue(), sizeof(double)); + break; + + case TypeClass_STRING: + { + pvData->vt = VT_BSTR; + ::rtl::OUString val; + rAnyVal >>= val; + pvData->bstrVal = SysAllocString((OLECHAR *)val.getStr()); + break; + } + + case TypeClass_VOID: + case TypeClass_HYPER: + case TypeClass_UNSIGNED_HYPER: + case TypeClass_TYPE: + case TypeClass_ANY: + case TypeClass_ENUM: + case TypeClass_TYPEDEF: + case TypeClass_STRUCT: + case TypeClass_UNION: + case TypeClass_EXCEPTION: + case TypeClass_SEQUENCE: + case TypeClass_ARRAY: + case TypeClass_INTERFACE: + { + Reference< XAccessible > pXAcc; + if(rAnyVal >>= pXAcc) + { + if(pXAcc.is()) + { + IAccessible* pIAcc = NULL; + get_IAccessibleFromXAccessible((long)pXAcc.get(), &pIAcc); + if(pIAcc == NULL) + { + Reference< XAccessibleContext > pXAccContext = pXAcc->getAccessibleContext(); + g_pAgent->InsertAccObj(pXAcc.get(),pXAccContext->getAccessibleParent().get()); + get_IAccessibleFromXAccessible((long)pXAcc.get(), &pIAcc); + } + if(pIAcc) + { + pIAcc->AddRef(); + + pvData->vt = VT_UNKNOWN; + pvData->pdispVal = (IAccessible2*)pIAcc; + break; + } + } + } + } + case TypeClass_SERVICE: + case TypeClass_MODULE: + case TypeClass_INTERFACE_METHOD: + case TypeClass_INTERFACE_ATTRIBUTE: + case TypeClass_UNKNOWN: + case TypeClass_PROPERTY: + case TypeClass_CONSTANT: + case TypeClass_CONSTANTS: + case TypeClass_SINGLETON: + case TypeClass_MAKE_FIXED_SIZE: + // Output the type string, if there is other uno value type. + pvData->vt = VT_BSTR; + pvData->bstrVal = SysAllocString(rAnyVal.getValueTypeName().getStr()); + break; + + default: + break; + } + } + else + { + VariantClear(pvData); + } +} + +STDMETHODIMP CMAccessible::Get_XAccChildID(long* childID) +{ + // #CHECK# + if(childID == NULL) + { + return E_FAIL; + } + *childID = m_dChildID; + return S_OK; +} +STDMETHODIMP CMAccessible:: get_states(AccessibleStates __RPC_FAR *states ) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK XInterface# + if( !pRContext.is() ) + return E_FAIL; + + Reference<XAccessibleStateSet> pRStateSet = pRContext.get()->getAccessibleStateSet(); + if(!pRStateSet.is()) + { + return S_OK; + } + Sequence<short> pStates = pRStateSet->getStates(); + + + long count = pStates.getLength() ; + *states = 0x0; + for( int i = 0; i < count; i++ ) + { + for( int j = 0; j < sizeof(UNO_STATES) / sizeof(UNO_STATES[0]); j++ ) + { + if( pStates[i] == UNO_STATES[j] ) + { + *states |= IA2_STATES[j]; + break; + } + } + } + return S_OK; + + + LEAVE_PROTECTED_BLOCK +} + +// return the UNO roles +STDMETHODIMP CMAccessible:: get_extendedRole( BSTR __RPC_FAR * ) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + +STDMETHODIMP CMAccessible:: get_localizedExtendedRole( BSTR __RPC_FAR * ) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} +STDMETHODIMP CMAccessible:: get_nExtendedStates( long __RPC_FAR * ) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + + +STDMETHODIMP CMAccessible:: get_localizedExtendedStates( long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + return E_NOTIMPL; + + LEAVE_PROTECTED_BLOCK +} + + +STDMETHODIMP CMAccessible:: get_indexInParent( long __RPC_FAR *accParentIndex) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + // #CHECK# + if(accParentIndex == NULL) + return E_INVALIDARG; + + // #CHECK XInterface# + if( !pRContext.is() ) + return E_FAIL; + + *accParentIndex = pRContext.get()->getAccessibleIndexInParent(); + return S_OK; + + + LEAVE_PROTECTED_BLOCK +} +STDMETHODIMP CMAccessible:: get_locale( IA2Locale __RPC_FAR *locale ) +{ + + CHECK_ENABLE_INF + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(locale == NULL) + return E_INVALIDARG; + // #CHECK XInterface# + + if( !pRContext.is() ) + return E_FAIL; + + ::com::sun::star::lang::Locale unoLoc = pRContext.get()->getLocale(); + locale->language = SysAllocString((OLECHAR*)unoLoc.Language.getStr()); + locale->country = SysAllocString((OLECHAR*)unoLoc.Country.getStr()); + locale->variant = SysAllocString((OLECHAR*)unoLoc.Variant.getStr()); + + return S_OK; + + LEAVE_PROTECTED_BLOCK +} + +DWORD GetMSAAStateFromUNO(short xState) +{ + DWORD IState = STATE_SYSTEM_UNAVAILABLE; + switch( xState ) + { + case /*AccessibleStateType::*/AccessibleStateType::BUSY: + IState = STATE_SYSTEM_BUSY; + break; + case /*AccessibleStateType::*/AccessibleStateType::CHECKED: + IState = STATE_SYSTEM_CHECKED; + break; + case /*AccessibleStateType::*/AccessibleStateType::DEFUNC: + IState = STATE_SYSTEM_UNAVAILABLE; + break; + case /*AccessibleStateType::*/AccessibleStateType::EXPANDED: + IState = STATE_SYSTEM_EXPANDED; + break; + case /*AccessibleStateType::*/AccessibleStateType::FOCUSABLE: + IState = STATE_SYSTEM_FOCUSABLE; + break; + case /*AccessibleStateType::*/AccessibleStateType::FOCUSED: + IState = STATE_SYSTEM_FOCUSED; + break; + case /*AccessibleStateType::*/AccessibleStateType::INDETERMINATE: + IState = STATE_SYSTEM_MIXED; + break; + case /*AccessibleStateType::*/AccessibleStateType::MULTI_SELECTABLE: + IState = STATE_SYSTEM_MULTISELECTABLE; + break; + case /*AccessibleStateType::*/AccessibleStateType::PRESSED: + IState = STATE_SYSTEM_PRESSED; + break; + case /*AccessibleStateType::*/AccessibleStateType::RESIZABLE: + IState = STATE_SYSTEM_SIZEABLE; + break; + case /*AccessibleStateType::*/AccessibleStateType::SELECTABLE: + IState = STATE_SYSTEM_SELECTABLE; + break; + case /*AccessibleStateType::*/AccessibleStateType::SELECTED: + IState = STATE_SYSTEM_SELECTED; + break; + case /*AccessibleStateType::*/AccessibleStateType::ARMED: + IState = STATE_SYSTEM_FOCUSED; + break; + case /*AccessibleStateType::*/AccessibleStateType::EXPANDABLE: + IState = STATE_SYSTEM_COLLAPSED; + break; + default: + break; + } + return IState; +} + +STDMETHODIMP CMAccessible:: get_appName( BSTR __RPC_FAR *name) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(name == NULL) + return E_INVALIDARG; + + *name = SysAllocString(OLESTR("Hannover")); + return S_OK; + LEAVE_PROTECTED_BLOCK +} +STDMETHODIMP CMAccessible:: get_appVersion(BSTR __RPC_FAR *version) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(version == NULL) + return E_INVALIDARG; + *version=SysAllocString(OLESTR("3.0")); + return S_OK; + LEAVE_PROTECTED_BLOCK +} +STDMETHODIMP CMAccessible:: get_toolkitName(BSTR __RPC_FAR *name) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(name == NULL) + return E_INVALIDARG; + *name = SysAllocString(OLESTR(" ")); + return S_OK; + LEAVE_PROTECTED_BLOCK +} +STDMETHODIMP CMAccessible:: get_toolkitVersion(BSTR __RPC_FAR *version) +{ + + ENTER_PROTECTED_BLOCK + ISDESTROY() + if(version == NULL) + return E_INVALIDARG; + *version = SysAllocString(OLESTR(" ")); + return S_OK; + LEAVE_PROTECTED_BLOCK +} + + +STDMETHODIMP CMAccessible::get_attributes(/*[out]*/ BSTR *pAttr) +{ + CHECK_ENABLE_INF + Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); + if( !pRContext.is() ) + { + return E_FAIL; + } + Reference<XAccessibleExtendedAttributes> pRXI(pRContext,UNO_QUERY); + if( !pRXI.is() ) + return E_FAIL; + else + { + com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleExtendedAttributes> pRXAttr; + pRXAttr = pRXI.get(); + ::com::sun::star::uno::Any anyVal = pRXAttr->getExtendedAttributes(); + + ::rtl::OUString val; + anyVal >>= val; + + if(*pAttr) + SAFE_SYSFREESTRING(*pAttr); + *pAttr = SysAllocString((OLECHAR *)val.getStr()); + + return S_OK; + } +} + diff --git a/winaccessibility/source/UAccCOM/MAccessible.h b/winaccessibility/source/UAccCOM/MAccessible.h new file mode 100644 index 000000000000..5e298e257f6a --- /dev/null +++ b/winaccessibility/source/UAccCOM/MAccessible.h @@ -0,0 +1,294 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __MACCESSIBLE_H_ +#define __MACCESSIBLE_H_ + +#include <Windows.h> +#include "resource.h" // main symbols +#include <vector> +#include <map> +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleSelection.hpp> +#include <com/sun/star/accessibility/XAccessibleAction.hpp> +#include <AccObjectManagerAgent.hxx> +#include "EnumVariant.h" +#ifndef __ACCCOMMON_H_ +#include "acccommon.h" +#endif +#ifndef _RTL_USTRING_HXX_ +#include <rtl/ustring.hxx> +#endif + +#define CHILDID_SELF 0 +#define OBJID_WINDOW ((LONG)0x00000000) +#define OBJID_SYSMENU ((LONG)0xFFFFFFFF) +#define OBJID_TITLEBAR ((LONG)0xFFFFFFFE) +#define OBJID_MENU ((LONG)0xFFFFFFFD) +#define OBJID_CLIENT ((LONG)0xFFFFFFFC) +#define OBJID_VSCROLL ((LONG)0xFFFFFFFB) +#define OBJID_HSCROLL ((LONG)0xFFFFFFFA) +#define OBJID_SIZEGRIP ((LONG)0xFFFFFFF9) +#define OBJID_CARET ((LONG)0xFFFFFFF8) +#define OBJID_CURSOR ((LONG)0xFFFFFFF7) +#define OBJID_ALERT ((LONG)0xFFFFFFF6) +#define OBJID_SOUND ((LONG)0xFFFFFFF5) +#define OBJID_QUERYCLASSNAMEIDX ((LONG)0xFFFFFFF4) +#define OBJID_NATIVEOM ((LONG)0xFFFFFFF0) + +using namespace rtl; +/** + *This class implements IMAccessible interface, which inherits from IAccessible2, and + *in turn inherits from IAccessible. So its methods include the methods defined only in + *IAccessible, plus the methods defined only in IAccessible2, plus the methods defined + *only in IMAccessible. + */ +class ATL_NO_VTABLE CMAccessible : + public CComObjectRoot, + public CComCoClass<CMAccessible, &CLSID_MAccessible>, + public IDispatchImpl<IMAccessible, &IID_IMAccessible, &LIBID_UACCCOMLib>, + public IServiceProvider, + public IAccessibleApplication +{ + typedef map< const GUID, CComPtr<IUnknown> ,ltComp > XGUIDToComObjHash; + + typedef HRESULT (WINAPI _UNO_AGGCREATORFUNC)(void*, REFIID, LPVOID*); + + struct _UNO_AGGMAP_ENTRY + { + const IID* piid; + _UNO_AGGCREATORFUNC* pfnCreateInstance; + int XIFIndex; + }; + + enum XInterfaceIndex { + XI_COMPONENT = 0x01, + XI_TEXT = 0x02, + XI_TABLE = 0x03, + XI_EDITABLETEXT = 0x04, + XI_IMAGE = 0x05, + XI_SELECTION = 0x06, + XI_EXTENDEDCOMP = 0x07, + XI_VALUE = 0x08, + XI_KEYBINDING = 0x09, + XI_ACTION = 0x0A, + XI_HYPERTEXT = 0x0B, + XI_HYPERLINK = 0x0C, + XI_ATTRIBUTE = 0x0D, + XI_NULL = -1 + }; + +public: + CMAccessible(); + virtual ~CMAccessible(); + DECLARE_REGISTRY_RESOURCEID(IDR_MACCESSIBLE) + + DECLARE_GET_CONTROLLING_UNKNOWN() + + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CMAccessible) + COM_INTERFACE_ENTRY(IMAccessible) + COM_INTERFACE_ENTRY(IAccessible) + COM_INTERFACE_ENTRY(IAccessible2) + COM_INTERFACE_ENTRY(IDispatch) + COM_INTERFACE_ENTRY(IAccessibleApplication) + COM_INTERFACE_ENTRY(IServiceProvider) + COM_INTERFACE_ENTRY_FUNC_BLIND(NULL,_SmartQI) + END_COM_MAP() + + // AGGREGATE OBJECT MAP + BEGIN_AGGOBJECT_MAP(CMAccessible) + AGGOBJECT_ENTRY(IID_IAccessibleComponent, CLSID_AccComponent, COMPONENT) + AGGOBJECT_ENTRY(IID_IAccessibleText, CLSID_AccText, TEXT) + AGGOBJECT_ENTRY(IID_IAccessibleEditableText, CLSID_AccEditableText, EDITABLETEXT) + AGGOBJECT_ENTRY(IID_IAccessibleImage, CLSID_AccImage, IMAGE) + AGGOBJECT_ENTRY(IID_IAccessibleTable, CLSID_AccTable, TABLE) + AGGOBJECT_ENTRY(IID_IAccessibleAction, CLSID_AccAction, ACTION) + AGGOBJECT_ENTRY(IID_IAccessibleValue, CLSID_AccValue, VALUE) + AGGOBJECT_ENTRY(IID_IAccessibleHypertext, CLSID_AccHypertext, HYPERTEXT) + AGGOBJECT_ENTRY(IID_IAccessibleHyperlink, CLSID_AccHyperLink, HYPERLINK) + + + END_AGGOBJECT_MAP() + + // IMAccessible + STDMETHOD(put_accValue)(VARIANT varChild,BSTR szValue); + STDMETHOD(put_accName)(VARIANT varChild,BSTR szName); + STDMETHOD(accDoDefaultAction)(VARIANT varChild); + STDMETHOD(accHitTest)(long xLeft,long yTop,VARIANT *pvarChild); + STDMETHOD(accNavigate)(long navDir,VARIANT varStart,VARIANT *pvarEndUpAt); + STDMETHOD(accLocation)(long *pxLeft,long *pyTop,long *pcxWidth,long *pcyHeight,VARIANT varChild); + STDMETHOD(accSelect)(long flagsSelect,VARIANT varChild); + STDMETHOD(get_accDefaultAction)( VARIANT varChild,BSTR *pszDefaultAction); + STDMETHOD(get_accSelection)(VARIANT *pvarChildren); + STDMETHOD(get_accFocus)(VARIANT *pvarChild); + STDMETHOD(get_accKeyboardShortcut)( VARIANT varChild,BSTR *pszKeyboardShortcut); + STDMETHOD(get_accHelpTopic)(BSTR *pszHelpFile,VARIANT varChild,long *pidTopic); + STDMETHOD(get_accHelp)(VARIANT varChild,BSTR *pszHelp); + STDMETHOD(get_accState)(VARIANT varChild,VARIANT *pvarState); + STDMETHOD(get_accRole)(VARIANT varChild,VARIANT *pvarRole); + STDMETHOD(get_accDescription)(VARIANT varChild,BSTR *pszDescription); + STDMETHOD(get_accValue)( VARIANT varChild,BSTR *pszValue); + STDMETHOD(get_accName)(VARIANT varChild,BSTR *pszName); + STDMETHOD(get_accChild)(VARIANT varChild,IDispatch **ppdispChild); + STDMETHOD(get_accChildCount)(long *pcountChildren); + STDMETHOD(get_accParent)( IDispatch **ppdispParent); + + // methods which are defined only in the IAccessible2 + // These methods only declare here, and their implementation bodies are empty now. + STDMETHOD(get_nRelations)( long __RPC_FAR *nRelations) ; + STDMETHOD(get_relation)( long relationIndex, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation) ; + STDMETHOD(get_relations)( long maxRelations, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation, long __RPC_FAR *nRelations) ; + STDMETHOD(role)(long __RPC_FAR *role); + STDMETHOD(get_nActions)(long __RPC_FAR *nActions); + STDMETHOD(scrollTo)(enum IA2ScrollType scrollType); + STDMETHOD(scrollToPoint)(enum IA2CoordinateType coordinateType, long x, long y); + STDMETHOD(get_groupPosition)(long __RPC_FAR *groupLevel,long __RPC_FAR *similarItemsInGroup,long __RPC_FAR *positionInGroup); + STDMETHOD(get_states)( AccessibleStates __RPC_FAR *states ); + STDMETHOD(get_extendedRole)( BSTR __RPC_FAR *extendedRole ); + STDMETHOD(get_localizedExtendedRole)( BSTR __RPC_FAR *localizedExtendedRole ); + STDMETHOD(get_nExtendedStates)( long __RPC_FAR *nExtendedStates); + STDMETHOD(get_extendedStates)( long maxExtendedStates, BSTR __RPC_FAR *__RPC_FAR *extendedStates, long __RPC_FAR *nExtendedStates); + STDMETHOD(get_localizedExtendedStates)(long maxLocalizedExtendedStates,BSTR __RPC_FAR *__RPC_FAR *localizedExtendedStates,long __RPC_FAR *nLocalizedExtendedStates); + STDMETHOD(get_uniqueID)(long __RPC_FAR *uniqueID); + STDMETHOD(get_windowHandle)(HWND __RPC_FAR *windowHandle); + STDMETHOD(get_indexInParent)( long __RPC_FAR *accParentIndex ); + STDMETHOD(get_locale)( IA2Locale __RPC_FAR *locale ); + STDMETHOD(get_attributes)(/*[out]*/ BSTR *pAttr); + + //IServiceProvider. + STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void** ppvObject); + + //IAccessibleApplication + STDMETHOD(get_appName)(BSTR __RPC_FAR *name); + STDMETHOD(get_appVersion)(BSTR __RPC_FAR *version); + STDMETHOD(get_toolkitName)(BSTR __RPC_FAR *name); + STDMETHOD(get_toolkitVersion)(BSTR __RPC_FAR *version); + + // methods which are defined only in IMAccessible + // These methods are provided for UNO management system. + // The UNO management system use these methods to put Accessibility + // information to COM. + STDMETHOD(Put_XAccName)(const OLECHAR __RPC_FAR *pszName); + STDMETHOD(Put_XAccRole)(unsigned short pRole); + STDMETHOD(DecreaseState)(DWORD pXSate); + STDMETHOD(IncreaseState)(DWORD pXSate); + STDMETHOD(SetState)(DWORD pXSate); + STDMETHOD(Put_XAccDescription)(const OLECHAR __RPC_FAR *pszDescription); + STDMETHOD(Put_XAccValue)(const OLECHAR __RPC_FAR *pszAccValue); + STDMETHOD(Put_XAccLocation)(const Location sLocation); + STDMETHOD(Put_XAccFocus)(long dChildID); + STDMETHOD(Put_XAccParent)(IMAccessible __RPC_FAR *pIParent); + STDMETHOD(Put_XAccWindowHandle)(HWND hwnd); + STDMETHOD(Put_XAccChildID)(long dChildID); + STDMETHOD(Put_XAccAgent)(long pAgent); + STDMETHOD(NotifyDestroy)(BOOL isDestroy); + STDMETHOD(Put_ActionDescription)( const OLECHAR* szAction); + STDMETHOD(SetDefaultAction)(long pAction); + STDMETHOD(GetUNOInterface)(long*); + STDMETHOD(SetXAccessible)(long); + +private: + OLECHAR* m_pszName; + OLECHAR* m_pszValue; + OLECHAR* m_pszActionDescription; + unsigned short m_iRole; + DWORD m_dState; + OLECHAR* m_pszDescription; + IMAccessible* m_pIParent; + Location m_sLocation; + + // identify a COM object/Acc object uniquely + long m_dChildID; + // specify the focus child ID in object self and its direct children + + long m_dFocusChildID; + // parent window handle,will be used in the future application, its value comes from UNO + + HWND m_hwnd; + + // the COM class which implements IEnumVARIANT interface,currently only used in + // the implementation of get_accSelection + CEnumVariant* m_pEnumVar; + + // specify if the XAccessible is invalid + BOOL m_isDestroy; + + XAccessible* pUNOInterface; + Reference< XAccessible > pRef; + XAccessible* pAchorUNOInterface; + XAccessibleAction* m_pXAction; + XAccessibleContext* pRContextInterface; + Reference<XAccessibleContext> pRContext; + +private: + + // the helper methods in order to implement the above public methods + IMAccessible* GetChildInterface(long dChildIndex);//notice here the parameter is child index,not child id + IMAccessible* GetNavigateChildForDM(VARIANT varCur,short flags);//for decendant manage + HRESULT GetFirstChild(VARIANT varStart,VARIANT* pvarEndUpAt);//for accNavigate implementation + HRESULT GetLastChild(VARIANT varStart,VARIANT* pvarEndUpAt);//for accNavigate implementation + HRESULT GetNextSibling(VARIANT varStart,VARIANT* pvarEndUpAt);//for accNavigate implementation + HRESULT GetPreSibling(VARIANT varStart,VARIANT* pvarEndUpAt);//for accNavigate implementation + BOOL IsDecendantManage();//identify whether the current COM belongs to manage_decendant roles + + // the following private methods are used to implement accSelect method + HRESULT SelectChild(XAccessible* pItem); + HRESULT DeSelectChild(XAccessible* pItem); + HRESULT SelectMutipleChidren( XAccessible** pItem,int size ); + HRESULT DeSelectMutipleChildren( XAccessible** pItem,int size ); + XAccessibleContext* GetContextByXAcc( XAccessible* pXAcc ); + Reference< XAccessibleSelection > GetSelection(); + // end accSelect implementation methods + BOOL GetXInterfaceFromXAccessible(XAccessible*, XInterface**, int); + HRESULT WINAPI SmartQI(void* pv, REFIID iid, void** ppvObject); + +public: + STDMETHOD(Get_XAccChildID)(/*[out,retval]*/ long* childID); + // AccObjectManagerAgent is a management object in UNO, here keep its pointer for + // the implementation of accNavigate when decendant manage happens for List,Tree, or Table + // AccObjectManagerAgent and the following UNO objects XAccessble,XAccessibleSelection, + // XAccessibleAction are all used to operate UNO accessiblility information directly when + // implement some specific MSAA methods,such as accSelection,accNavigate + static AccObjectManagerAgent* g_pAgent; + + static BOOL get_IAccessibleFromXAccessible(long pXAcc,IAccessible** ppIA); + BOOL m_bRequiresSave; + XGUIDToComObjHash m_containedObjects; + + static HRESULT WINAPI _SmartQI(void* pv, + REFIID iid, void** ppvObject, DWORD) + { + return ((CMAccessible*)pv)->SmartQI(pv,iid,ppvObject); + } + + static void get_OLECHARFromAny(Any& pAny, OLECHAR* pChar); + + static void get_OLECHAR4Numbering(const Any& pAny, short numberingLevel, const OUString& numberingPrefix,OLECHAR* pChar); + + // Helper function for data conversion. + static void ConvertAnyToVariant(const ::com::sun::star::uno::Any &rAnyVal, VARIANT *pvData); +}; + + + +#endif //__MACCESSIBLE_H_ diff --git a/winaccessibility/source/UAccCOM/MAccessible.rgs b/winaccessibility/source/UAccCOM/MAccessible.rgs new file mode 100644 index 000000000000..10bd2c02eb94 --- /dev/null +++ b/winaccessibility/source/UAccCOM/MAccessible.rgs @@ -0,0 +1,26 @@ +HKCR +{ + UAccCOM.MAccessible.1 = s 'MAccessible Class' + { + CLSID = s '{CF8DF8BA-44FE-4B10-BD2E-8C8CB322485F}' + } + UAccCOM.MAccessible = s 'MAccessible Class' + { + CLSID = s '{CF8DF8BA-44FE-4B10-BD2E-8C8CB322485F}' + CurVer = s 'UAccCOM.MAccessible.1' + } + NoRemove CLSID + { + ForceRemove {CF8DF8BA-44FE-4B10-BD2E-8C8CB322485F} = s 'MAccessible Class' + { + ProgID = s 'UAccCOM.MAccessible.1' + VersionIndependentProgID = s 'UAccCOM.MAccessible' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Both' + } + 'TypeLib' = s '{19ECB1B0-9376-4FF9-B580-223FC9C200B8}' + } + } +} diff --git a/winaccessibility/source/UAccCOM/Resource.h b/winaccessibility/source/UAccCOM/Resource.h new file mode 100644 index 000000000000..a4df8cde4aee --- /dev/null +++ b/winaccessibility/source/UAccCOM/Resource.h @@ -0,0 +1,70 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by UAccCOM.rc +// +#define WNT + +#define IDS_PROJNAME 100 +#define IDR_MACCESSIBLE 101 +#define IDR_ENUMVARIANT 106 +#define IDR_UNOXWRAPPER 107 +#define IDS_ACCCOMPONENT_DESC 108 +#define IDR_AccComponent 109 +#define IDS_ACCCONTEXT_DESC 110 +#define IDR_AccContext 111 +#define IDR_ACCRELATION 112 +#define IDR_ACCACTION 113 +#define IDS_ACCFONT_DESC 114 +#define IDR_AccFont 115 +#define IDS_ACCSELECTION_DESC 116 +#define IDR_AccSelection 117 +#define IDS_ACCEXTENDEDCOMPONENT_DESC 118 +#define IDR_AccExtendedComponent 119 +#define IDS_ACCTEXT_DESC 120 +#define IDR_AccText 121 +#define IDS_ACCEDITABLETEXT_DESC 122 +#define IDR_AccEditableText 123 +#define IDS_ACCHYPERTEXT_DESC 124 +#define IDR_AccHypertext 125 +#define IDS_ACCIMAGE_DESC 126 +#define IDR_AccImage 127 +#define IDS_ACCVALUE_DESC 128 +#define IDR_AccValue 129 +#define IDS_ACCTABLE_DESC 130 +#define IDR_ACCTABLE 131 +#define IDS_ACCHYPERLINK_DESC 132 +#define IDR_AccHyperLink 133 +#define IDS_ACCKEYBINDING_DESC 134 +#define IDR_AccKeyBinding 135 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 203 +#define _APS_NEXT_COMMAND_VALUE 32768 +#define _APS_NEXT_CONTROL_VALUE 201 +#define _APS_NEXT_SYMED_VALUE 137 +#endif +#endif diff --git a/winaccessibility/source/UAccCOM/StdAfx.cxx b/winaccessibility/source/UAccCOM/StdAfx.cxx new file mode 100644 index 000000000000..20fae718d15a --- /dev/null +++ b/winaccessibility/source/UAccCOM/StdAfx.cxx @@ -0,0 +1,29 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" + +#ifdef _ATL_STATIC_REGISTRY +#include <statreg.h> +#include <statreg.cpp> +#endif + +#include <atlimpl.cpp> diff --git a/winaccessibility/source/UAccCOM/UAccCOM.cxx b/winaccessibility/source/UAccCOM/UAccCOM.cxx new file mode 100644 index 000000000000..85471d13158b --- /dev/null +++ b/winaccessibility/source/UAccCOM/UAccCOM.cxx @@ -0,0 +1,109 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "resource.h" +#include <initguid.h> +#include "UAccCOM2.h" + +#include "UAccCOM_i.c" +#include "ia2_api_all_i.c" + +#include "MAccessible.h" +#include "EnumVariant.h" +#include "UNOXWrapper.h" +#include "AccComponent.h" +#include "AccRelation.h" +#include "AccAction.h" +#include "AccText.h" +#include "AccEditableText.h" +#include "AccImage.h" +#include "AccValue.h" +#include "AccTable.h" +#include "AccHyperLink.h" +#include "AccHyperText.h" + + +CComModule _Module; + +BEGIN_OBJECT_MAP(ObjectMap) +OBJECT_ENTRY(CLSID_MAccessible, CMAccessible) +OBJECT_ENTRY(CLSID_EnumVariant, CEnumVariant) +OBJECT_ENTRY(CLSID_AccComponent, CAccComponent) +OBJECT_ENTRY(CLSID_AccRelation, CAccRelation) +OBJECT_ENTRY(CLSID_AccAction, CAccAction) +OBJECT_ENTRY(CLSID_AccText, CAccText) +OBJECT_ENTRY(CLSID_AccEditableText, CAccEditableText) +OBJECT_ENTRY(CLSID_AccImage, CAccImage) +OBJECT_ENTRY(CLSID_AccValue, CAccValue) +OBJECT_ENTRY(CLSID_AccTable, CAccTable) +OBJECT_ENTRY(CLSID_AccHyperLink, CAccHyperLink) +OBJECT_ENTRY(CLSID_AccHypertext, CAccHypertext) +END_OBJECT_MAP() + +///////////////////////////////////////////////////////////////////////////// +// DLL Entry Point + +extern "C" + BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/) +{ + if (dwReason == DLL_PROCESS_ATTACH) + { + _Module.Init(ObjectMap, hInstance, &LIBID_UACCCOMLib); + DisableThreadLibraryCalls(hInstance); + } + else if (dwReason == DLL_PROCESS_DETACH) + _Module.Term(); + return TRUE; // ok +} + +///////////////////////////////////////////////////////////////////////////// +// Used to determine whether the DLL can be unloaded by OLE + +STDAPI DllCanUnloadNow(void) +{ + return (_Module.GetLockCount()==0) ? S_OK : E_FAIL; +} + +///////////////////////////////////////////////////////////////////////////// +// Returns a class factory to create an object of the requested type + +STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) +{ + return _Module.GetClassObject(rclsid, riid, ppv); +} + +///////////////////////////////////////////////////////////////////////////// +// DllRegisterServer - Adds entries to the system registry + +STDAPI DllRegisterServer(void) +{ + // registers object, typelib and all interfaces in typelib + return _Module.RegisterServer(TRUE); +} + +///////////////////////////////////////////////////////////////////////////// +// DllUnregisterServer - Removes entries from the system registry + +STDAPI DllUnregisterServer(void) +{ + return _Module.UnregisterServer(TRUE); +} diff --git a/winaccessibility/source/UAccCOM/UAccCOM.def b/winaccessibility/source/UAccCOM/UAccCOM.def new file mode 100644 index 000000000000..575a28143316 --- /dev/null +++ b/winaccessibility/source/UAccCOM/UAccCOM.def @@ -0,0 +1,7 @@ +LIBRARY "UAccCOM.DLL" + +EXPORTS + DllCanUnloadNow PRIVATE + DllGetClassObject PRIVATE + DllRegisterServer PRIVATE + DllUnregisterServer PRIVATE diff --git a/winaccessibility/source/UAccCOM/UAccCOM.rc b/winaccessibility/source/UAccCOM/UAccCOM.rc new file mode 100644 index 000000000000..f49903d777d6 --- /dev/null +++ b/winaccessibility/source/UAccCOM/UAccCOM.rc @@ -0,0 +1,149 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// Chinese (P.R.C.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS) +#ifdef _WIN32 +LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED +#pragma code_page(936) +#endif //_WIN32 + +///////////////////////////////////////////////////////////////////////////// +// +// REGISTRY +// + +IDR_MACCESSIBLE REGISTRY DISCARDABLE "MAccessible.rgs" +IDR_ENUMVARIANT REGISTRY DISCARDABLE "EnumVariant.rgs" +IDR_UNOXWRAPPER REGISTRY DISCARDABLE "UNOXWrapper.rgs" +IDR_AccComponent REGISTRY DISCARDABLE "AccComponent.rgs" +IDR_AccExtendedComponent REGISTRY DISCARDABLE "AccExtendedComponent.rgs" +IDR_ACCRELATION REGISTRY DISCARDABLE "AccRelation.rgs" +IDR_ACCACTION REGISTRY DISCARDABLE "AccAction.rgs" +IDR_AccFont REGISTRY DISCARDABLE "AccFont.rgs" +IDR_AccSelection REGISTRY DISCARDABLE "AccSelection.rgs" +IDR_AccText REGISTRY DISCARDABLE "AccText.rgs" +IDR_AccEditableText REGISTRY DISCARDABLE "AccEditableText.rgs" +IDR_AccImage REGISTRY DISCARDABLE "AccImage.rgs" +IDR_AccValue REGISTRY DISCARDABLE "AccValue.rgs" +IDR_ACCTABLE REGISTRY DISCARDABLE "AccTable.rgs" +IDR_AccHyperLink REGISTRY DISCARDABLE "AccHyperLink.rgs" +IDR_AccHypertext REGISTRY DISCARDABLE "AccHypertext.rgs" +IDR_AccKeyBinding REGISTRY DISCARDABLE "AccKeyBinding.rgs" +#endif // Chinese (P.R.C.) resources +///////////////////////////////////////////////////////////////////////////// + + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "1 TYPELIB ""UAccCOM.tlb""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + +// +// String Table +// + +STRINGTABLE DISCARDABLE +BEGIN + IDS_PROJNAME "UAccCOM" + IDS_ACCCOMPONENT_DESC "AccComponent Class" + IDS_ACCCONTEXT_DESC "AccContext Class" +END + +STRINGTABLE DISCARDABLE +BEGIN + IDS_ACCFONT_DESC "AccFont Class" + IDS_ACCSELECTION_DESC "AccSelection Class" + IDS_ACCEXTENDEDCOMPONENT_DESC "AccExtendedComponent Class" + IDS_ACCTEXT_DESC "AccText Class" + IDS_ACCEDITABLETEXT_DESC "AccEditableText Class" + IDS_ACCHYPERTEXT_DESC "AccHypertext Class" + IDS_ACCIMAGE_DESC "AccImage Class" +END + +STRINGTABLE DISCARDABLE +BEGIN + IDS_ACCVALUE_DESC "AccValue Class" + IDS_ACCTABLE_DESC "AccTable Class" + IDS_ACCHYPERLINK_DESC "AccHyperLink Class" + IDS_ACCKEYBINDING_DESC "AccKeyBinding Class" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +1 TYPELIB "UAccCOM.tlb" + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/winaccessibility/source/UAccCOM/UNOXWrapper.cxx b/winaccessibility/source/UAccCOM/UNOXWrapper.cxx new file mode 100644 index 000000000000..80427ca20049 --- /dev/null +++ b/winaccessibility/source/UAccCOM/UNOXWrapper.cxx @@ -0,0 +1,27 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#include "stdafx.h" +#include "UAccCOM2.h" +#include "UNOXWrapper.h" + +///////////////////////////////////////////////////////////////////////////// +// CUNOXWrapper diff --git a/winaccessibility/source/UAccCOM/UNOXWrapper.h b/winaccessibility/source/UAccCOM/UNOXWrapper.h new file mode 100644 index 000000000000..c80eb203df70 --- /dev/null +++ b/winaccessibility/source/UAccCOM/UNOXWrapper.h @@ -0,0 +1,72 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __UNOXWRAPPER_H_ +#define __UNOXWRAPPER_H_ + +#define WNT + +#include "resource.h" // main symbols + + +#include <com/sun/star/accessibility/XAccessible.hpp> +#include "UAccCOM2.h" + +/** + * CUNOXWrapper implements IUNOXWrapper interface. + */ +class ATL_NO_VTABLE CUNOXWrapper : public IUNOXWrapper +{ +public: + CUNOXWrapper() + { } + +public: + // IUNOXWrapper + + STDMETHOD(put_XInterface)(long pXInterface) + { + pUNOInterface = (com::sun::star::accessibility::XAccessible*)pXInterface; + return S_OK; + } + + STDMETHOD(put_XSubInterface)(long) + { + return S_OK; + } + + STDMETHOD(get_XInterface)(/*[out,retval]*/long *pXInterface) + { + *pXInterface = (long)pUNOInterface;//.get(); + return S_OK; + } + + STDMETHOD(get_XSubInterface)(/*[out,retval]*/long *) + { + return S_OK; + } + +protected: + + com::sun::star::accessibility::XAccessible* pUNOInterface; +}; + +#endif //__UNOXWRAPPER_H_ diff --git a/winaccessibility/source/UAccCOM/UNOXWrapper.rgs b/winaccessibility/source/UAccCOM/UNOXWrapper.rgs new file mode 100644 index 000000000000..8a52b08ae7f9 --- /dev/null +++ b/winaccessibility/source/UAccCOM/UNOXWrapper.rgs @@ -0,0 +1,26 @@ +HKCR +{ + UAccCOM.UNOXWrapper.1 = s 'UNOXWrapper Class' + { + CLSID = s '{AA360FB0-BC98-41C1-A885-BB921F5ED601}' + } + UAccCOM.UNOXWrapper = s 'UNOXWrapper Class' + { + CLSID = s '{AA360FB0-BC98-41C1-A885-BB921F5ED601}' + CurVer = s 'UAccCOM.UNOXWrapper.1' + } + NoRemove CLSID + { + ForceRemove {AA360FB0-BC98-41C1-A885-BB921F5ED601} = s 'UNOXWrapper Class' + { + ProgID = s 'UAccCOM.UNOXWrapper.1' + VersionIndependentProgID = s 'UAccCOM.UNOXWrapper' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + 'TypeLib' = s '{19ECB1B0-9376-4FF9-B580-223FC9C200B8}' + } + } +} diff --git a/winaccessibility/source/UAccCOM/acccommon.h b/winaccessibility/source/UAccCOM/acccommon.h new file mode 100644 index 000000000000..4c0451a65b0e --- /dev/null +++ b/winaccessibility/source/UAccCOM/acccommon.h @@ -0,0 +1,95 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +#ifndef __ACCCOMMON_H_ +#define __ACCCOMMON_H_ + + +//using namespace com::sun::star::accessibility; +//using namespace com::sun::star::uno; + + +//for MAccessible.cxx +struct ltComp +{ + bool operator()(REFGUID rguid1, REFGUID rguid2) const + { + if(((PLONG) &rguid1)[0] < ((PLONG) &rguid2)[0]) + return TRUE; + else if(((PLONG) &rguid1)[0] > ((PLONG) &rguid2)[0]) + return FALSE; + if(((PLONG) &rguid1)[1] < ((PLONG) &rguid2)[1]) + return TRUE; + else if(((PLONG) &rguid1)[1] > ((PLONG) &rguid2)[1]) + return FALSE; + if(((PLONG) &rguid1)[2] < ((PLONG) &rguid2)[2]) + return TRUE; + else if(((PLONG) &rguid1)[2] > ((PLONG) &rguid2)[2]) + return FALSE; + if(((PLONG) &rguid1)[3] < ((PLONG) &rguid2)[3]) + return TRUE; + else if(((PLONG) &rguid1)[3] > ((PLONG) &rguid2)[3]) + return FALSE; + return FALSE; + } +}; + +#define BEGIN_AGGOBJECT_MAP(x) \ + static _UNO_AGGMAP_ENTRY* WINAPI _GetAggEntries() { \ + static _UNO_AGGMAP_ENTRY _aggentries[] = { +#define END_AGGOBJECT_MAP() {NULL, NULL,NULL}}; \ + return _aggentries;} +#define AGGOBJECT_ENTRY(iid, clsid, ifindex) {&iid, \ + CComAggregateCreator< CComObject<CMAccessible>, &clsid >::CreateInstance,\ + XI_##ifindex}, + +enum DM_NIR { + DM_FIRSTCHILD = 0x00, + DM_LASTCHILD = 0x01, + DM_NEXTCHILD = 0x02, + DM_PREVCHILD = 0x03 +}; + +inline BOOL ImplIsEqualGUID(REFGUID rguid1, REFGUID rguid2) +{ + return ( + ((PLONG) &rguid1)[0] == ((PLONG) &rguid2)[0] && + ((PLONG) &rguid1)[1] == ((PLONG) &rguid2)[1] && + ((PLONG) &rguid1)[2] == ((PLONG) &rguid2)[2] && + ((PLONG) &rguid1)[3] == ((PLONG) &rguid2)[3]); +} +#define InlineIsEqualGUID ImplIsEqualGUID +//End + +//for AccAction.cxx +#define CODEENTRY(key) \ + {KEYCODE_##key, L#key} +#define countof(x) (sizeof(x)/sizeof(x[0])) + +#define SELECT L"Select" +#define PRESS L"Press" +#define UNCHECK L"UnCheck" +#define CHECK L"Check" +//End + +static DWORD GetMSAAStateFromUNO(short xState); + +#endif diff --git a/winaccessibility/source/UAccCOM/stdafx.h b/winaccessibility/source/UAccCOM/stdafx.h new file mode 100644 index 000000000000..c9b2a23cc7c4 --- /dev/null +++ b/winaccessibility/source/UAccCOM/stdafx.h @@ -0,0 +1,64 @@ +/************************************************************** + * + * 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. + * + *************************************************************/ + +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, +// but are changed infrequently + +#if !defined(AFX_STDAFX_H__5E2F9072_190F_47C7_8003_4D44FD308CB9__INCLUDED_) +#define AFX_STDAFX_H__5E2F9072_190F_47C7_8003_4D44FD308CB9__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define STRICT +#ifndef _WIN32_WINNT +#define _WIN32_WINNT 0x0400 +#endif +//#define _ATL_APARTMENT_THREADED + +#include <atlbase.h> +// You may derive a class from CComModule and use it if you want to override +// something, but do not change the name of _Module +extern CComModule _Module; +#include <atlcom.h> + +#define ENTER_PROTECTED_BLOCK \ + try \ + { + +#define LEAVE_PROTECTED_BLOCK \ + } \ + catch(...) \ + { \ + return E_FAIL; \ + } + +#define SAFE_SYSFREESTRING(x) { ::SysFreeString(x); x=NULL; } + +#include <windows.h> +#undef OPAQUE +#include "CheckEnableAccessible.h" +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__5E2F9072_190F_47C7_8003_4D44FD308CB9__INCLUDED) |