LibreOffice Module winaccessibility (master) 1
MAccessible.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include <UAccCOM.h>
21#include "MAccessible.h"
22
23#include <algorithm>
24#include <cstddef>
25
26#include "AccAction.h"
27#include "AccRelation.h"
28#include "AccComponent.h"
29#include "AccText.h"
30#include "AccEditableText.h"
31#include "AccImage.h"
32#include "AccTable.h"
33#include "AccTableCell.h"
34#include "AccValue.h"
35#include "AccHypertext.h"
36#include "AccHyperLink.h"
37
38#include <rtl/ustrbuf.hxx>
39#include <sal/log.hxx>
40#include <unotools/configmgr.hxx>
41#include <vcl/svapp.hxx>
42#include <o3tl/char16_t2wchar_t.hxx>
43#include <comphelper/AccessibleImplementationHelper.hxx>
44
45#include <com/sun/star/accessibility/XAccessibleText.hpp>
46#include <com/sun/star/accessibility/XAccessibleEditableText.hpp>
47#include <com/sun/star/accessibility/XAccessibleImage.hpp>
48#include <com/sun/star/accessibility/XAccessibleTable.hpp>
49#include <com/sun/star/accessibility/XAccessibleExtendedComponent.hpp>
50#include <com/sun/star/accessibility/XAccessibleAction.hpp>
51#include <com/sun/star/accessibility/XAccessibleKeyBinding.hpp>
52#include <com/sun/star/accessibility/XAccessibleHypertext.hpp>
53#include <com/sun/star/accessibility/XAccessibleHyperlink.hpp>
54#include <com/sun/star/accessibility/XAccessibleRelationSet.hpp>
55#include <com/sun/star/accessibility/AccessibleStateType.hpp>
56#include <com/sun/star/accessibility/AccessibleRole.hpp>
57#include <com/sun/star/accessibility/XAccessibleGroupPosition.hpp>
58#include <com/sun/star/accessibility/XAccessibleValue.hpp>
59#include <com/sun/star/accessibility/XAccessibleExtendedAttributes.hpp>
60#include <com/sun/star/style/LineSpacing.hpp>
61#include <com/sun/star/style/TabStop.hpp>
62#include <com/sun/star/container/XIndexReplace.hpp>
63
64
65using namespace com::sun::star::uno;
66using namespace com::sun::star::accessibility;
67using namespace com::sun::star::accessibility::AccessibleStateType;
68
69namespace {
70
71enum class XInterfaceType {
72 XI_COMPONENT,
73 XI_TEXT,
74 XI_TABLE,
75 XI_TABLECELL,
76 XI_EDITABLETEXT,
77 XI_IMAGE,
78 XI_SELECTION,
79 XI_EXTENDEDCOMP,
80 XI_VALUE,
81 XI_KEYBINDING,
82 XI_ACTION,
83 XI_HYPERTEXT,
84 XI_HYPERLINK,
85 XI_ATTRIBUTE
86};
87
88template <class Interface>
89bool queryXInterface(XAccessible* pXAcc, XInterface** ppXI)
90{
91 if (!pXAcc)
92 return false;
93
94 Reference<XAccessibleContext> pRContext = pXAcc->getAccessibleContext();
95 if (!pRContext.is())
96 return false;
97
98 Reference<Interface> pRXI(pRContext, UNO_QUERY);
99 if (!pRXI.is())
100 return false;
101
102 *ppXI = pRXI.get();
103 return true;
104}
105
106// Since there's no specific XInterface for table cells, this
107// method checks that the accessible's parent is a table
108// (implements XAccessibleTable) and pXAcc's context implements
109// XAccessibleComponent.
110bool queryTableCell(XAccessible* pXAcc, XInterface** ppXI)
111{
112 XInterface* pXInterface = nullptr;
113
114 const bool bSupportsInterface = queryXInterface<XAccessibleComponent>(pXAcc, &pXInterface);
115 if (!bSupportsInterface)
116 return false;
117
118 // check whether parent is a table (its accessible context implements XAccessibleTable)
119 XInterface* pParentXInterface = nullptr;
120 Reference<XAccessible> xParentAcc = pXAcc->getAccessibleContext()->getAccessibleParent();
121 const bool bParentIsTable = queryXInterface<XAccessibleTable>(xParentAcc.get(), &pParentXInterface);
122
123 if (!bParentIsTable)
124 return false;
125
126 *ppXI = pXInterface;
127 return true;
128}
129
130}
131
132// IA2 states mapping, and name
133// maintenance the consistency, change one array, change the three all
134long const IA2_STATES[] =
135{
136 IA2_STATE_ACTIVE, // = 0x1;
137 IA2_STATE_ARMED, // = 0x2;
138 IA2_STATE_DEFUNCT, // = 0x4;
139 IA2_STATE_EDITABLE, // = 0x8;
140 IA2_STATE_HORIZONTAL, // = 0x10;
141 IA2_STATE_ICONIFIED, // = 0x20;
142 IA2_STATE_INVALID_ENTRY, // = 0x80;
143 IA2_STATE_MANAGES_DESCENDANTS, // = 0x100;
144 IA2_STATE_MODAL, // = 0x200;
145 IA2_STATE_MULTI_LINE, // = 0x400;
146 IA2_STATE_OPAQUE, // = 0x800;
147 IA2_STATE_REQUIRED, // = 0x2000;
148 IA2_STATE_SELECTABLE_TEXT, // = 0x3000;
149 IA2_STATE_SINGLE_LINE, // = 0x4000;
150 IA2_STATE_STALE, // = 0x8000;
151 IA2_STATE_SUPPORTS_AUTOCOMPLETION, // = 0x10000;
152 IA2_STATE_TRANSIENT, //= 0x20000;
153 IA2_STATE_VERTICAL // = 0x40000;
154};
155
156sal_Int64 const UNO_STATES[] =
157{
158 ACTIVE,
159 ARMED,
160 DEFUNC,
161 EDITABLE,
162 HORIZONTAL,
163 ICONIFIED,
164 -1, //IA2_STATE_INVALID_ENTRY
165 MANAGES_DESCENDANTS,
166 MODAL,
167 MULTI_LINE,
168 OPAQUE,
169 -1, //IA2_STATE_REQUIRED
170 -1, //IA2_STATE_SELECTABLE_TEXT
171 SINGLE_LINE,
172 STALE,
173 -1, //IA2_STATE_SUPPORTS_AUTOCOMPLETION
174 TRANSIENT, //IA2_STATE_TRANSIENT
175 VERTICAL
176};
177
178using namespace com::sun::star::accessibility::AccessibleRole;
179
180
181AccObjectManagerAgent* CMAccessible::g_pAgent = nullptr;
182
183CMAccessible::CMAccessible():
184m_pszName(nullptr),
185m_pszValue(nullptr),
186m_pszActionDescription(nullptr),
187m_iRole(0x00),
188m_dState(0x00),
189m_pIParent(nullptr),
190m_dChildID(0x00),
191m_dFocusChildID(UACC_NO_FOCUS),
192m_hwnd(nullptr),
193m_isDestroy(false)
194{
195 CEnumVariant::Create(&m_pEnumVar);
196 m_containedObjects.clear();
197}
198
199CMAccessible::~CMAccessible()
200{
201 SolarMutexGuard g;
202
203 if(m_pszName!=nullptr)
204 {
205 SysFreeString(std::exchange(m_pszName, nullptr));
206 }
207 if(m_pszValue!=nullptr)
208 {
209 SysFreeString(std::exchange(m_pszValue, nullptr));
210 }
211
212 if(m_pszActionDescription!=nullptr)
213 {
214 SysFreeString(std::exchange(m_pszActionDescription, nullptr));
215 }
216
217 if(m_pIParent)
218 {
219 m_pIParent->Release();
220 m_pIParent=nullptr;
221 }
222 m_pEnumVar->Release();
223 m_containedObjects.clear();
224}
225
234COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accParent(IDispatch **ppdispParent)
235{
236 SolarMutexGuard g;
237
238 try {
239 if (m_isDestroy) return S_FALSE;
240 // #CHECK#
241 if(ppdispParent == nullptr)
242 {
243 return E_INVALIDARG;
244 }
245
246 if(m_pIParent)
247 {
248 *ppdispParent = m_pIParent;
249 (*ppdispParent)->AddRef();
250 return S_OK;
251 }
252 else if(m_hwnd)
253 {
254 HRESULT hr = AccessibleObjectFromWindow(m_hwnd, OBJID_WINDOW, IID_IAccessible, reinterpret_cast<void**>(ppdispParent));
255 if (!SUCCEEDED(hr) || !*ppdispParent)
256 {
257 return S_FALSE;
258 }
259 return S_OK;
260 }
261 return S_FALSE;
262
263 } catch(...) { return E_FAIL; }
264}
265
271COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accChildCount(long *pcountChildren)
272{
273 SolarMutexGuard g;
274
275 try {
276 if (m_isDestroy) return S_FALSE;
277 // #CHECK#
278 if(pcountChildren == nullptr)
279 {
280 return E_INVALIDARG;
281 }
282
283 if (!m_xAccessible.is())
284 return S_FALSE;
285
286 Reference<XAccessibleContext> const pRContext =
287 m_xAccessible->getAccessibleContext();
288 if( pRContext.is() )
289 {
290 sal_Int64 nChildCount = pRContext->getAccessibleChildCount();
291 if (nChildCount > std::numeric_limits<long>::max())
292 {
293 SAL_WARN("iacc2", "CMAccessible::get_accChildCount: Child count exceeds maximum long value, "
294 "returning max long.");
295 nChildCount = std::numeric_limits<long>::max();
296 }
297
298 *pcountChildren = nChildCount;
299 }
300
301 return S_OK;
302
303 } catch(...) { return E_FAIL; }
304}
305
313COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accChild(VARIANT varChild, IDispatch **ppdispChild)
314{
315 SolarMutexGuard g;
316
317 try {
318 if (m_isDestroy) return S_FALSE;
319 // #CHECK#
320 if(ppdispChild == nullptr)
321 {
322 return E_INVALIDARG;
323 }
324 if(varChild.vt==VT_I4)
325 {
326 //get child interface pointer due to child ID
327 if(varChild.lVal==CHILDID_SELF)
328 {
329 AddRef();
330 *ppdispChild = this;
331 return S_OK;
332 }
333 *ppdispChild = GetChildInterface(varChild.lVal);
334 if((*ppdispChild) == nullptr)
335 return E_FAIL;
336 (*ppdispChild)->AddRef();
337 return S_OK;
338 }
339 return S_FALSE;
340
341 } catch(...) { return E_FAIL; }
342}
343
351COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accName(VARIANT varChild, BSTR *pszName)
352{
353 SolarMutexGuard g;
354
355 try {
356 if (m_isDestroy) return S_FALSE;
357 // #CHECK#
358 if(pszName == nullptr)
359 {
360 return E_INVALIDARG;
361 }
362 if(varChild.vt==VT_I4)
363 {
364 if(varChild.lVal==CHILDID_SELF)
365 {
366 SysFreeString(*pszName);
367 *pszName = SysAllocString(m_pszName);
368 return S_OK;
369 }
370
371 long lVal = varChild.lVal;
372 varChild.lVal = CHILDID_SELF;
373 IMAccessible *pChild = this->GetChildInterface(lVal);
374 if(!pChild)
375 return E_FAIL;
376 return pChild->get_accName(varChild,pszName);
377 }
378 return S_FALSE;
379
380 } catch(...) { return E_FAIL; }
381}
382
390COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accValue(VARIANT varChild, BSTR *pszValue)
391{
392 SolarMutexGuard g;
393
394 try {
395 if (m_isDestroy) return S_FALSE;
396 // #CHECK#
397 if( pszValue == nullptr )
398 {
399 return E_INVALIDARG;
400 }
401 if( varChild.vt==VT_I4 )
402 {
403 if(varChild.lVal==CHILDID_SELF)
404 {
405 if(m_dState & STATE_SYSTEM_PROTECTED)
406 return E_ACCESSDENIED;
407
408 if ( m_pszValue !=nullptr && wcslen(m_pszValue) == 0 )
409 return S_OK;
410
411 SysFreeString(*pszValue);
412 *pszValue = SysAllocString(m_pszValue);
413 return S_OK;
414 }
415
416 long lVal = varChild.lVal;
417 varChild.lVal = CHILDID_SELF;
418 IMAccessible *pChild = this->GetChildInterface(lVal);
419 if(!pChild)
420 return E_FAIL;
421 return pChild->get_accValue(varChild,pszValue);
422 }
423 return S_FALSE;
424
425 } catch(...) { return E_FAIL; }
426}
427
435COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accDescription(VARIANT varChild, BSTR *pszDescription)
436{
437 SolarMutexGuard g;
438
439 try {
440 if (m_isDestroy) return S_FALSE;
441 // #CHECK#
442 if(pszDescription == nullptr)
443 {
444 return E_INVALIDARG;
445 }
446 if(varChild.vt==VT_I4)
447 {
448 if(varChild.lVal==CHILDID_SELF)
449 {
450 if (!m_xAccessible.is())
451 return S_FALSE;
452
453 Reference<XAccessibleContext> xContext = m_xAccessible->getAccessibleContext();
454 if (!xContext.is())
455 return S_FALSE;
456
457 const OUString sDescription = xContext->getAccessibleDescription();
458 SysFreeString(*pszDescription);
459 *pszDescription = SysAllocString(o3tl::toW(sDescription.getStr()));
460 return S_OK;
461 }
462
463 long lVal = varChild.lVal;
464 varChild.lVal = CHILDID_SELF;
465 IMAccessible *pChild = this->GetChildInterface(lVal);
466 if(!pChild)
467 return E_FAIL;
468 return pChild->get_accDescription(varChild,pszDescription);
469 }
470 return S_FALSE;
471
472 } catch(...) { return E_FAIL; }
473}
474
482COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accRole(VARIANT varChild, VARIANT *pvarRole)
483{
484 SolarMutexGuard g;
485
486 try {
487 if (m_isDestroy) return S_FALSE;
488 // #CHECK#
489 if(pvarRole == nullptr)
490 {
491 return E_INVALIDARG;
492 }
493 if(varChild.vt == VT_I4)
494 {
495
496 if(varChild.lVal == CHILDID_SELF)
497 {
498 VariantInit(pvarRole);
499 pvarRole->vt = VT_I4;
500
501 if (m_iRole < IA2_ROLE_CAPTION)
502 pvarRole->lVal = m_iRole;
503 else
504 pvarRole->lVal = ROLE_SYSTEM_CLIENT;
505
506 return S_OK;
507 }
508
509
510 long lVal = varChild.lVal;
511 varChild.lVal = CHILDID_SELF;
512 IMAccessible *pChild = this->GetChildInterface(lVal);
513 if(!pChild)
514 return E_FAIL;
515 return pChild->get_accRole(varChild,pvarRole);
516 }
517 return S_FALSE;
518
519 } catch(...) { return E_FAIL; }
520}
521
529COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accState(VARIANT varChild, VARIANT *pvarState)
530{
531 SolarMutexGuard g;
532
533 try {
534 if (m_isDestroy) return S_FALSE;
535 // #CHECK#
536 if(pvarState == nullptr)
537 {
538 return E_INVALIDARG;
539 }
540 if(varChild.vt==VT_I4)
541 {
542 if(varChild.lVal == CHILDID_SELF)
543 {
544 if (m_xAccessible.is())
545 {
546 Reference<XAccessibleContext> const pContext =
547 m_xAccessible->getAccessibleContext();
548 if(pContext.is())
549 {
550 // add the STATE_SYSTEM_LINKED state
551 Reference< XAccessibleHypertext > pRHypertext(pContext,UNO_QUERY);
552 if(pRHypertext.is())
553 {
554 if( pRHypertext->getHyperLinkCount() > 0 )
555 m_dState |= STATE_SYSTEM_LINKED;
556 else
557 m_dState &= ~STATE_SYSTEM_LINKED;
558 }
559 else
560 m_dState &= ~STATE_SYSTEM_LINKED;
561 }
562 }
563
564 VariantInit(pvarState);
565 pvarState->vt = VT_I4;
566 pvarState->lVal = m_dState;
567 return S_OK;
568 }
569
570 long lVal = varChild.lVal;
571 varChild.lVal = CHILDID_SELF;
572 IMAccessible *pChild = this->GetChildInterface(lVal);
573 if(!pChild)
574 return E_FAIL;
575 return pChild->get_accState(varChild,pvarState);
576 }
577 return S_FALSE;
578
579 } catch(...) { return E_FAIL; }
580}
581
589COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accHelp(VARIANT, BSTR *)
590{
591 return E_NOTIMPL;
592}
593
603COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accHelpTopic(BSTR *, VARIANT, long *)
604{
605 return E_NOTIMPL;
606}
607
608static bool GetMnemonicChar( const OUString& aStr, sal_Unicode* wStr)
609{
610 for (sal_Int32 i = 0;; i += 2) {
611 i = aStr.indexOf('~', i);
612 if (i == -1 || i == aStr.getLength() - 1) {
613 return false;
614 }
615 auto c = aStr[i + 1];
616 if (c != '~') {
617 *wStr = c;
618 return true;
619 }
620 }
621}
622
630COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut)
631{
632 SolarMutexGuard g;
633
634 try {
635
636 if (m_isDestroy) return S_FALSE;
637 // #CHECK#
638 if(pszKeyboardShortcut == nullptr)
639 {
640 return E_INVALIDARG;
641 }
642
643 if(varChild.vt==VT_I4)
644 {
645 if(varChild.lVal == CHILDID_SELF)
646 {
647 if (m_xAccessible.is())
648 {
649 Reference<XAccessibleContext> const pRContext =
650 m_xAccessible->getAccessibleContext();
651 if( !pRContext.is() )
652 return S_FALSE;
653
654 Reference<XAccessibleAction> pRXI(pRContext,UNO_QUERY);
655
656 OUString wString;
657
658 if( pRXI.is() && pRXI->getAccessibleActionCount() >= 1)
659 {
660 Reference< XAccessibleKeyBinding > binding = pRXI->getAccessibleActionKeyBinding(0);
661 if( binding.is() )
662 {
663 long nCount = binding->getAccessibleKeyBindingCount();
664 if(nCount >= 1)
665 {
666 wString = comphelper::GetkeyBindingStrByXkeyBinding( binding->getAccessibleKeyBinding(0) );
667 }
668 }
669 }
670 if(wString.isEmpty())
671 {
672 Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet();
673 if(!pRrelationSet.is())
674 {
675 return S_FALSE;
676 }
677
678 long nRelCount = pRrelationSet->getRelationCount();
679
680 // Modified by Steve Yin, for SODC_1552
681 if( /*nRelCount <= 0 &&*/ m_iRole == ROLE_SYSTEM_TEXT )
682 {
683 VARIANT varParentRole;
684 VariantInit( &varParentRole );
685
686 if (m_pIParent
687 && SUCCEEDED(m_pIParent->get_accRole(varChild, &varParentRole))
688 && varParentRole.lVal == ROLE_SYSTEM_COMBOBOX) // edit in comboBox
689 {
690 m_pIParent->get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
691 return S_OK;
692 }
693 }
694
695 AccessibleRelation *paccRelation = nullptr;
696 AccessibleRelation accRelation;
697 for(int i=0; i<nRelCount ; i++)
698 {
699 if( pRrelationSet->getRelation(i).RelationType == 6 )
700 {
701 accRelation = pRrelationSet->getRelation(i);
702 paccRelation = &accRelation;
703 }
704 }
705
706 if(paccRelation == nullptr)
707 return S_FALSE;
708
709 Sequence< Reference< XInterface > > xTargets = paccRelation->TargetSet;
710 Reference<XInterface> pRAcc = xTargets[0];
711
712 XAccessible* pXAcc = static_cast<XAccessible*>(pRAcc.get());
713
714 Reference<XAccessibleContext> pRLebelContext = pXAcc->getAccessibleContext();
715 if(!pRLebelContext.is())
716 return S_FALSE;
717
718 pRrelationSet = pRLebelContext->getAccessibleRelationSet();
719 nRelCount = pRrelationSet->getRelationCount();
720
721 paccRelation = nullptr;
722 for(int j=0; j<nRelCount ; j++)
723 {
724 if( pRrelationSet->getRelation(j).RelationType == 5 )
725 {
726 accRelation = pRrelationSet->getRelation(j);
727 paccRelation = &accRelation;
728 }
729 }
730
731 if(paccRelation)
732 {
733 xTargets = paccRelation->TargetSet;
734 pRAcc = xTargets[0];
735 if (m_xAccessible.get() != static_cast<XAccessible*>(pRAcc.get()))
736 return S_FALSE;
737 }
738
739 Reference<XAccessibleExtendedComponent> pRXIE(pRLebelContext,UNO_QUERY);
740 if(!pRXIE.is())
741 return S_FALSE;
742
743 OUString ouStr = pRXIE->getTitledBorderText();
744 sal_Unicode key;
745 if(GetMnemonicChar(ouStr, &key))
746 {
747 wString = "Alt+" + OUStringChar(key);
748 }
749 else
750 return S_FALSE;
751 }
752
753 SysFreeString(*pszKeyboardShortcut);
754 *pszKeyboardShortcut = SysAllocString(o3tl::toW(wString.getStr()));
755
756 return S_OK;
757 }
758 else
759 {
760 return S_FALSE;
761 }
762 }
763
764 long lVal = varChild.lVal;
765 varChild.lVal = CHILDID_SELF;
766 IMAccessible *pChild = this->GetChildInterface(lVal);
767 if(!pChild)
768 return E_FAIL;
769
770 return pChild->get_accKeyboardShortcut(varChild,pszKeyboardShortcut);
771 }
772 return S_FALSE;
773
774 } catch(...) { return E_FAIL; }
775}
776
783COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accFocus(VARIANT *pvarChild)
784{
785 SolarMutexGuard g;
786
787 try {
788 if (m_isDestroy) return S_FALSE;
789 // #CHECK#
790 if(pvarChild == nullptr)
791 {
792 return E_INVALIDARG;
793 }
794 if( m_dFocusChildID==UACC_NO_FOCUS )
795 {
796 pvarChild->vt = VT_EMPTY;//no focus on the object and its children
797 return S_OK;
798 }
799 //if the descendant of current object has focus indicated by m_dFocusChildID, return the IDispatch of this focused object
800 else
801 {
802 IMAccessible* pIMAcc = nullptr;
803 g_pAgent->GetIAccessibleFromResID(m_dFocusChildID,&pIMAcc);
804 if (pIMAcc == nullptr)
805 {
806 return E_FAIL;
807 }
808 pIMAcc->AddRef();
809 pvarChild->vt = VT_DISPATCH;
810 pvarChild->pdispVal = pIMAcc;
811
812 }
813 return S_OK;
814
815 } catch(...) { return E_FAIL; }
816}
817
826COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accSelection(VARIANT *pvarChildren)
827{
828 SolarMutexGuard g;
829
830 try {
831 if (m_isDestroy) return S_FALSE;
832 // #CHECK#
833 if(pvarChildren == nullptr)
834 {
835 return E_INVALIDARG;
836 }
837 switch(m_pEnumVar->GetCountOfElements())
838 {
839 case 0:
840 pvarChildren->vt = VT_EMPTY;
841 break;
842 case 1:
843 VARIANT varTmp[1];
844 ULONG count;
845 VariantInit(&varTmp[0]);
846 m_pEnumVar->Next(1,varTmp,&count);
847 if(count!=1)
848 return S_FALSE;
849 pvarChildren->vt = VT_DISPATCH;
850 pvarChildren->pdispVal = varTmp[0].pdispVal;
851 pvarChildren->pdispVal->AddRef();
852 VariantClear(&varTmp[0]);
853 m_pEnumVar->Reset();
854 break;
855 default:
856 pvarChildren->vt = VT_UNKNOWN;
857 IEnumVARIANT* pClone;
858 m_pEnumVar->Clone(&pClone);
859 pClone->Reset();
860 pvarChildren->punkVal = pClone;
861 break;
862 }
863 return S_OK;
864
865 } catch(...) { return E_FAIL; }
866}
867
878COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild)
879{
880 SolarMutexGuard g;
881
882 try {
883 if (m_isDestroy) return S_FALSE;
884 // #CHECK#
885 if(pxLeft == nullptr || pyTop == nullptr || pcxWidth == nullptr || pcyHeight == nullptr)
886 {
887 return E_INVALIDARG;
888 }
889
890 if(varChild.vt==VT_I4)
891 {
892 if(varChild.lVal==CHILDID_SELF)
893 {
894 if (!m_xAccessible.is())
895 return S_FALSE;
896
897 Reference<XAccessibleContext> const pRContext =
898 m_xAccessible->getAccessibleContext();
899 if( !pRContext.is() )
900 return S_FALSE;
901 Reference< XAccessibleComponent > pRComponent(pRContext,UNO_QUERY);
902 if( !pRComponent.is() )
903 return S_FALSE;
904
905 css::awt::Point pCPoint = pRComponent->getLocationOnScreen();
906 css::awt::Size pCSize = pRComponent->getSize();
907 *pxLeft = pCPoint.X;
908 *pyTop = pCPoint.Y;
909 *pcxWidth = pCSize.Width;
910 *pcyHeight = pCSize.Height;
911 return S_OK;
912 }
913 }
914 return S_FALSE;
915
916 } catch(...) { return E_FAIL; }
917}
918
926COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt)
927{
928 SolarMutexGuard g;
929
930 try {
931 if (m_isDestroy) return S_FALSE;
932 // #CHECK#
933 if(pvarEndUpAt == nullptr)
934 {
935 return E_INVALIDARG;
936 }
937 HRESULT ret = E_FAIL;
938 switch (navDir)
939 {
940 case NAVDIR_FIRSTCHILD:
941 ret = GetFirstChild(varStart,pvarEndUpAt);
942 break;
943 case NAVDIR_LASTCHILD:
944 ret = GetLastChild(varStart,pvarEndUpAt);
945 break;
946 case NAVDIR_NEXT:
947 ret = GetNextSibling(varStart,pvarEndUpAt);
948 break;
949 case NAVDIR_PREVIOUS:
950 ret = GetPreSibling(varStart,pvarEndUpAt);
951 break;
952 case NAVDIR_DOWN://do not implement temporarily
953 break;
954 case NAVDIR_UP://do not implement temporarily
955 break;
956 case NAVDIR_LEFT://do not implement temporarily
957 break;
958 case NAVDIR_RIGHT://do not implement temporarily
959 break;
960 default:
961 break;
962 }
963 return ret;
964
965 } catch(...) { return E_FAIL; }
966}
967
968COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::accHitTest(long xLeft, long yTop, VARIANT *pvarChild)
969{
970 SolarMutexGuard g;
971
972 try {
973 if (m_isDestroy) return S_FALSE;
974 // #CHECK#
975 if(pvarChild == nullptr)
976 {
977 return E_INVALIDARG;
978 }
979 long x, y, w, h;
980 VARIANT varSelf;
981 VariantInit(&varSelf);
982 varSelf.vt = VT_I4;
983 varSelf.lVal = CHILDID_SELF;
984 accLocation(&x,&y,&w,&h,varSelf);
985 if( (x < xLeft && (x + w) >xLeft) && (y < yTop && (y + h) >yTop) )
986 {
987 sal_Int64 i, nCount;
988 pvarChild->vt = VT_EMPTY;
989 Reference< XAccessibleContext > pRContext = GetContextByXAcc(m_xAccessible.get());
990 nCount = pRContext->getAccessibleChildCount();
991 if(nCount > 256)
992 return E_FAIL;
993 IMAccessible* child = nullptr;
994 for( i = 0; i<nCount; i++)
995 {
996
997 child = GetChildInterface(i + 1);
998 if(child && child->accHitTest(xLeft,yTop,pvarChild) == S_OK)
999 break;
1000 }
1001
1002 if(pvarChild->vt == VT_DISPATCH)
1003 return S_OK;
1004
1005 if( i < nCount)
1006 {
1007 pvarChild->vt = VT_DISPATCH;
1008 pvarChild->pdispVal = child;
1009 child->AddRef();
1010 }
1011 else
1012 {
1013 pvarChild->vt = VT_I4;
1014 pvarChild->lVal = CHILDID_SELF;
1015 }
1016 return S_OK;
1017 }
1018 return S_FALSE;
1019
1020 } catch(...) { return E_FAIL; }
1021}
1022
1029COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::QueryService(REFGUID guidService, REFIID riid, void** ppvObject)
1030{
1031 if( InlineIsEqualGUID(guidService, IID_IAccessible) )
1032 return QueryInterface(riid, ppvObject);
1033 return S_FALSE;
1034}
1035
1040COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::put_accName(VARIANT, BSTR)
1041{
1042 return E_NOTIMPL;
1043}
1044
1052COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::put_accValue(VARIANT varChild, BSTR szValue)
1053{
1054 SolarMutexGuard g;
1055
1056 try {
1057 if (m_isDestroy) return S_FALSE;
1058 if(varChild.vt==VT_I4)
1059 {
1060 if(varChild.lVal==CHILDID_SELF)
1061 {
1062 SysFreeString(m_pszValue);
1063 m_pszValue=SysAllocString(szValue);
1064 return S_OK;
1065 }
1066
1067 long lVal = varChild.lVal;
1068 varChild.lVal = CHILDID_SELF;
1069 IMAccessible *pChild = this->GetChildInterface(lVal);
1070 if(!pChild)
1071 return E_FAIL;
1072 return pChild->put_accValue(varChild,szValue);
1073 }
1074 return E_FAIL;
1075
1076 } catch(...) { return E_FAIL; }
1077}
1078
1084COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccName(const OLECHAR __RPC_FAR *pszName)
1085{
1086 // internal IMAccessible - no mutex meeded
1087
1088 try {
1089 if (m_isDestroy) return S_FALSE;
1090 // #CHECK#
1091 if(pszName == nullptr)
1092 {
1093 return E_INVALIDARG;
1094 }
1095
1096 SysFreeString(m_pszName);
1097 m_pszName = SysAllocString(pszName);
1098 if(m_pszName==nullptr)
1099 return E_FAIL;
1100 return S_OK;
1101
1102 } catch(...) { return E_FAIL; }
1103}
1104
1110COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccRole(unsigned short pRole)
1111{
1112 // internal IMAccessible - no mutex meeded
1113
1114 m_iRole = pRole;
1115 return S_OK;
1116}
1117
1123COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::DecreaseState(DWORD pXSate)
1124{
1125 // internal IMAccessible - no mutex meeded
1126
1127 m_dState &= (~pXSate);
1128 return S_OK;
1129}
1130
1136COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::IncreaseState(DWORD pXSate)
1137{
1138 // internal IMAccessible - no mutex meeded
1139
1140 m_dState |= pXSate;
1141 return S_OK;
1142}
1143
1149COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::SetState(DWORD pXSate)
1150{
1151 // internal IMAccessible - no mutex meeded
1152
1153 m_dState = pXSate;
1154 return S_OK;
1155}
1156
1162COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccValue(const OLECHAR __RPC_FAR *pszAccValue)
1163{
1164 // internal IMAccessible - no mutex meeded
1165
1166 try {
1167 if (m_isDestroy) return S_FALSE;
1168 // #CHECK#
1169 if(pszAccValue == nullptr)
1170 {
1171 return E_INVALIDARG;
1172 }
1173 SysFreeString(m_pszValue);
1174 m_pszValue = SysAllocString(pszAccValue);
1175 if(m_pszValue==nullptr)
1176 return E_FAIL;
1177 return S_OK;
1178
1179 } catch(...) { return E_FAIL; }
1180}
1181
1188COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccWindowHandle(HWND hwnd)
1189{
1190 // internal IMAccessible - no mutex meeded
1191
1192 try {
1193 if (m_isDestroy) return S_FALSE;
1194 m_hwnd = hwnd;
1195 return S_OK;
1196
1197 } catch(...) { return E_FAIL; }
1198}
1199
1205COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccFocus(long dChildID)
1206{
1207 // internal IMAccessible - no mutex meeded
1208
1209 try {
1210 if (m_isDestroy) return S_FALSE;
1211
1212 if(dChildID==CHILDID_SELF)
1213 {
1214 if(m_pIParent)
1215 {
1216 m_pIParent->Put_XAccFocus(m_dChildID);
1217 }
1218 }
1219 else
1220 {
1221 m_dFocusChildID = dChildID;
1222 //traverse all ancestors to set the focused child ID so that when the get_accFocus is called on
1223 //any of the ancestors, this id can be used to get the IAccessible of focused object.
1224 if(m_pIParent)
1225 {
1226 m_pIParent->Put_XAccFocus(dChildID);
1227 }
1228 }
1229 return S_OK;
1230
1231 } catch(...) { return E_FAIL; }
1232}
1233
1240COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccParent(IMAccessible __RPC_FAR *pIParent)
1241{
1242 // internal IMAccessible - no mutex meeded
1243
1244 this->m_pIParent = pIParent;
1245
1246 if(pIParent)
1247 m_pIParent->AddRef();
1248
1249 return S_OK;
1250}
1251
1257COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccChildID(long dChildID)
1258{
1259 // internal IMAccessible - no mutex meeded
1260
1261 this->m_dChildID = dChildID;
1262 return S_OK;
1263}
1264
1270COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_XAccAgent(hyper pAgent)
1271{
1272 // internal IMAccessible - no mutex meeded
1273
1274 g_pAgent = reinterpret_cast<AccObjectManagerAgent*>(pAgent);
1275 return S_OK;
1276}
1277
1284COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::NotifyDestroy()
1285{
1286 // internal IMAccessible - no mutex meeded
1287
1288 m_isDestroy = true;
1289 m_xAccessible.clear();
1290 return S_OK;
1291}
1292
1302IMAccessible* CMAccessible::GetChildInterface(long dChildID)//for test
1303{
1304 if(dChildID<0)
1305 {
1306 if(g_pAgent)
1307 {
1308 IMAccessible* pIMAcc = nullptr;
1309 g_pAgent->GetIAccessibleFromResID(dChildID,&pIMAcc);
1310 return pIMAcc;
1311 }
1312 return nullptr;
1313 }
1314 else
1315 {
1316 if (!m_xAccessible.is())
1317 return nullptr;
1318
1319 Reference<XAccessibleContext> const pRContext =
1320 m_xAccessible->getAccessibleContext();
1321 if( !pRContext.is() )
1322 return nullptr;
1323
1324 if(dChildID<1 || dChildID>pRContext->getAccessibleChildCount())
1325 return nullptr;
1326
1327 IAccessible* pChild = nullptr;
1328 Reference< XAccessible > pXChild = pRContext->getAccessibleChild(dChildID-1);
1329 bool isGet = get_IAccessibleFromXAccessible(pXChild.get(), &pChild);
1330
1331 if(!isGet)
1332 {
1333 g_pAgent->InsertAccObj(pXChild.get(), m_xAccessible.get(), m_hwnd);
1334 isGet = get_IAccessibleFromXAccessible(pXChild.get(), &pChild);
1335 }
1336
1337 if(isGet)
1338 {
1339 IMAccessible* pIMAcc = static_cast<IMAccessible*>(pChild);
1340 return pIMAcc;
1341 }
1342 }
1343
1344 return nullptr;
1345}
1346
1353IMAccessible* CMAccessible::GetNavigateChildForDM(VARIANT varCur, short flags)
1354{
1355
1356 XAccessibleContext* pXContext = GetContextByXAcc(m_xAccessible.get());
1357 if(pXContext==nullptr)
1358 {
1359 return nullptr;
1360 }
1361
1362 sal_Int64 count = pXContext->getAccessibleChildCount();
1363 if(count<1)
1364 {
1365 return nullptr;
1366 }
1367
1368 IMAccessible* pCurChild = nullptr;
1369 union {
1370 XAccessible* pChildXAcc;
1371 hyper nHyper = 0;
1372 };
1373 Reference<XAccessible> pRChildXAcc;
1374 XAccessibleContext* pChildContext = nullptr;
1375 sal_Int64 index = 0, delta = 0;
1376 switch(flags)
1377 {
1378 case DM_FIRSTCHILD:
1379 pRChildXAcc = pXContext->getAccessibleChild(0);
1380 break;
1381 case DM_LASTCHILD:
1382 pRChildXAcc = pXContext->getAccessibleChild(count-1);
1383 break;
1384 case DM_NEXTCHILD:
1385 case DM_PREVCHILD:
1386 pCurChild = GetChildInterface(varCur.lVal);
1387 if(pCurChild==nullptr)
1388 {
1389 return nullptr;
1390 }
1391 pCurChild->GetUNOInterface(&nHyper);
1392 if(pChildXAcc==nullptr)
1393 {
1394 return nullptr;
1395 }
1396 pChildContext = GetContextByXAcc(pChildXAcc);
1397 if(pChildContext == nullptr)
1398 {
1399 return nullptr;
1400 }
1401 delta = (flags==DM_NEXTCHILD)?1:-1;
1402 //currently, getAccessibleIndexInParent is error in UNO for
1403 //some kind of List,such as ValueSet, the index will be less 1 than
1404 //what should be, need to fix UNO code
1405 index = pChildContext->getAccessibleIndexInParent()+delta;
1406 if((index>=0)&&(index<=count-1))
1407 {
1408 pRChildXAcc = pXContext->getAccessibleChild(index);
1409 }
1410 break;
1411 default:
1412 break;
1413 }
1414
1415 if(!pRChildXAcc.is())
1416 {
1417 return nullptr;
1418 }
1419 pChildXAcc = pRChildXAcc.get();
1420 g_pAgent->InsertAccObj(pChildXAcc, m_xAccessible.get());
1421 return g_pAgent->GetIMAccByXAcc(pChildXAcc);
1422}
1423
1435HRESULT CMAccessible::GetFirstChild(VARIANT varStart,VARIANT* pvarEndUpAt)
1436{
1437
1438 try {
1439 if (m_isDestroy) return S_FALSE;
1440 // #CHECK#
1441 if(pvarEndUpAt == nullptr)
1442 {
1443 return E_INVALIDARG;
1444 }
1445 if(varStart.vt != VT_I4)
1446 {
1447 pvarEndUpAt->vt = VT_EMPTY;
1448 return E_INVALIDARG;
1449 }
1450
1451 pvarEndUpAt->pdispVal = GetNavigateChildForDM(varStart, DM_FIRSTCHILD);
1452 if(pvarEndUpAt->pdispVal)
1453 {
1454 pvarEndUpAt->pdispVal->AddRef();
1455 pvarEndUpAt->vt = VT_DISPATCH;
1456 return S_OK;
1457 }
1458
1459 pvarEndUpAt->vt = VT_EMPTY;
1460 return E_FAIL;
1461
1462 } catch(...) { return E_FAIL; }
1463}
1464
1472HRESULT CMAccessible::GetLastChild(VARIANT varStart,VARIANT* pvarEndUpAt)
1473{
1474
1475 try {
1476 if (m_isDestroy) return S_FALSE;
1477 // #CHECK#
1478 if(pvarEndUpAt == nullptr)
1479 {
1480 return E_INVALIDARG;
1481 }
1482 if(varStart.vt != VT_I4)
1483 {
1484 pvarEndUpAt->vt = VT_EMPTY;
1485 return E_INVALIDARG;
1486 }
1487
1488 pvarEndUpAt->pdispVal = GetNavigateChildForDM(varStart, DM_LASTCHILD);
1489 if(pvarEndUpAt->pdispVal)
1490 {
1491 pvarEndUpAt->pdispVal->AddRef();
1492 pvarEndUpAt->vt = VT_DISPATCH;
1493 return S_OK;
1494 }
1495 pvarEndUpAt->vt = VT_EMPTY;
1496 return E_FAIL;
1497
1498 } catch(...) { return E_FAIL; }
1499}
1500
1508HRESULT CMAccessible::GetNextSibling(VARIANT varStart,VARIANT* pvarEndUpAt)
1509{
1510
1511 try {
1512 if (m_isDestroy) return S_FALSE;
1513 if(varStart.vt != VT_I4)
1514 {
1515 pvarEndUpAt->vt = VT_EMPTY;
1516 return E_INVALIDARG;
1517 }
1518
1519 Reference<XAccessibleContext> const pRContext =
1520 GetContextByXAcc(m_xAccessible.get());
1521 if(pRContext.is())
1522 {
1523 varStart.iVal = sal_Int16(pRContext->getAccessibleIndexInParent() + 2);
1524 if(m_pIParent)
1525 if( m_pIParent->get_accChild(varStart,&pvarEndUpAt->pdispVal) == S_OK)
1526 {
1527 pvarEndUpAt->vt = VT_DISPATCH;
1528 return S_OK;
1529 }
1530 }
1531 pvarEndUpAt->vt = VT_EMPTY;
1532 return E_FAIL;
1533
1534 } catch(...) { return E_FAIL; }
1535}
1536
1543HRESULT CMAccessible::GetPreSibling(VARIANT varStart,VARIANT* pvarEndUpAt)
1544{
1545
1546 try {
1547 if (m_isDestroy) return S_FALSE;
1548 // #CHECK#
1549 if(pvarEndUpAt == nullptr)
1550 {
1551 return E_INVALIDARG;
1552 }
1553 if(varStart.vt != VT_I4)
1554 {
1555 pvarEndUpAt->vt = VT_EMPTY;
1556 return E_INVALIDARG;
1557 }
1558
1559 Reference<XAccessibleContext> const pRContext =
1560 GetContextByXAcc(m_xAccessible.get());
1561 if(pRContext.is())
1562 {
1563 varStart.iVal = sal_Int16(pRContext->getAccessibleIndexInParent());
1564 if(m_pIParent && varStart.iVal > 0)
1565 if( m_pIParent->get_accChild(varStart,&pvarEndUpAt->pdispVal) == S_OK)
1566 {
1567 pvarEndUpAt->vt = VT_DISPATCH;
1568 return S_OK;
1569 }
1570 }
1571 pvarEndUpAt->vt = VT_EMPTY;
1572 return E_FAIL;
1573
1574 } catch(...) { return E_FAIL; }
1575}
1576
1580COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_nRelations( long __RPC_FAR *nRelations)
1581{
1582 SolarMutexGuard g;
1583
1584 try {
1585 if (m_isDestroy) return S_FALSE;
1586
1587 // #CHECK#
1588 if(nRelations == nullptr)
1589 {
1590 return E_INVALIDARG;
1591 }
1592
1593 *nRelations = 0;
1594
1595 if (!m_xContext.is())
1596 return E_FAIL;
1597 Reference<XAccessibleRelationSet> pRrelationSet =
1598 m_xContext->getAccessibleRelationSet();
1599 if(!pRrelationSet.is())
1600 {
1601 *nRelations = 0;
1602 return S_OK;
1603 }
1604
1605 *nRelations = pRrelationSet->getRelationCount();
1606 return S_OK;
1607
1608 } catch(...) { return E_FAIL; }
1609}
1610
1611COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_relation( long relationIndex, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation)
1612{
1613 SolarMutexGuard g;
1614
1615 try {
1616 if (m_isDestroy) return S_FALSE;
1617 // #CHECK#
1618 if(relation == nullptr)
1619 {
1620 return E_INVALIDARG;
1621 }
1622
1623 if (!m_xContext.is())
1624 return E_FAIL;
1625
1626
1627 long nMax = 0;
1628 get_nRelations(&nMax);
1629
1630 *relation = static_cast<IAccessibleRelation*>(::CoTaskMemAlloc(sizeof(IAccessibleRelation)));
1631
1632 // #CHECK Memory Allocation#
1633 if(*relation == nullptr)
1634 {
1635 return E_FAIL;
1636 }
1637
1638 if( relationIndex < nMax )
1639 {
1640 Reference<XAccessibleRelationSet> const pRrelationSet =
1641 m_xContext->getAccessibleRelationSet();
1642 if(!pRrelationSet.is())
1643 {
1644
1645 return E_FAIL;
1646 }
1647
1648 IAccessibleRelation* pRelation = nullptr;
1649 HRESULT hr = createInstance<CAccRelation>(IID_IAccessibleRelation,
1650 &pRelation);
1651 if(SUCCEEDED(hr))
1652 {
1653 IUNOXWrapper* wrapper = nullptr;
1654 hr = pRelation->QueryInterface(IID_IUNOXWrapper, reinterpret_cast<void**>(&wrapper));
1655 if(SUCCEEDED(hr))
1656 {
1657 AccessibleRelation accRelation = pRrelationSet->getRelation(relationIndex);
1658 wrapper->put_XSubInterface(
1659 reinterpret_cast<hyper>(&accRelation));
1660 wrapper->Release();
1661 *relation = pRelation;
1662 return S_OK;
1663 }
1664
1665 }
1666 }
1667
1668 return E_FAIL;
1669
1670 } catch(...) { return E_FAIL; }
1671}
1672
1673COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_relations( long, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation, long __RPC_FAR *nRelations)
1674{
1675 SolarMutexGuard g;
1676
1677 try {
1678 if (m_isDestroy) return S_FALSE;
1679
1680 // #CHECK#
1681 if(relation == nullptr || nRelations == nullptr)
1682 {
1683 return E_INVALIDARG;
1684 }
1685 // #CHECK XInterface#
1686
1687 if (!m_xContext.is())
1688 return E_FAIL;
1689
1690 Reference<XAccessibleRelationSet> const pRrelationSet =
1691 m_xContext->getAccessibleRelationSet();
1692 if(!pRrelationSet.is())
1693 {
1694 *nRelations = 0;
1695 return S_OK;
1696 }
1697
1698 long nCount = pRrelationSet->getRelationCount();
1699
1700 *relation = static_cast<IAccessibleRelation*>(::CoTaskMemAlloc(nCount*sizeof(IAccessibleRelation)));
1701
1702 // #CHECK Memory Allocation#
1703 if(*relation == nullptr)
1704 {
1705 return E_FAIL;
1706 }
1707
1708 for(int i=0; i<nCount ; i++)
1709 {
1710 IAccessibleRelation* pRelation = nullptr;
1711 HRESULT hr = createInstance<CAccRelation>(IID_IAccessibleRelation,
1712 &pRelation);
1713 if(SUCCEEDED(hr))
1714 {
1715 IUNOXWrapper* wrapper = nullptr;
1716 hr = pRelation->QueryInterface(IID_IUNOXWrapper, reinterpret_cast<void**>(&wrapper));
1717 if(SUCCEEDED(hr))
1718 {
1719 AccessibleRelation accRelation = pRrelationSet->getRelation(i);
1720 wrapper->put_XSubInterface(
1721 reinterpret_cast<hyper>(&accRelation));
1722 wrapper->Release();
1723 }
1724 relation[i] = pRelation;
1725 }
1726 }
1727
1728 *nRelations = nCount;
1729 return S_OK;
1730
1731 } catch(...) { return E_FAIL; }
1732}
1733
1734COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::role(long __RPC_FAR *role)
1735{
1736 SolarMutexGuard g;
1737
1738 try {
1739
1740 (*role) = m_iRole;
1741
1742 return S_OK;
1743
1744 } catch(...) { return E_FAIL; }
1745}
1746
1747
1748COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_nActions(long __RPC_FAR *nActions)
1749{
1750 SolarMutexGuard g;
1751
1752 try
1753 {
1754 if (m_isDestroy) return S_FALSE;
1755 // #CHECK#
1756 if(nActions == nullptr)
1757 {
1758 return E_INVALIDARG;
1759 }
1760 *nActions = 0;
1761 IAccessibleAction* pAcc = nullptr;
1762 HRESULT hr = QueryInterface(IID_IAccessibleAction, reinterpret_cast<void**>(&pAcc));
1763 if( hr == S_OK )
1764 {
1765 pAcc->nActions(nActions);
1766 pAcc->Release();
1767 }
1768
1769 return S_OK;
1770 }
1771 catch(...)
1772 {
1773 *nActions = 0;
1774 return S_OK;
1775 }
1776}
1777
1778
1779COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::scrollToPoint(enum IA2CoordinateType, long, long)
1780{
1781 return E_NOTIMPL;
1782}
1783
1784COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::scrollTo(enum IA2ScrollType)
1785{
1786 return E_NOTIMPL;
1787}
1788
1789static XAccessible* getTheParentOfMember(XAccessible* pXAcc)
1790{
1791 // #CHECK#
1792 if(pXAcc == nullptr)
1793 {
1794 return nullptr;
1795 }
1796 Reference<XAccessibleContext> pRContext = pXAcc->getAccessibleContext();
1797 Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet();
1798 sal_Int32 nRelations = pRrelationSet->getRelationCount();
1799 for(sal_Int32 i=0 ; i<nRelations ; i++)
1800 {
1801 AccessibleRelation accRelation = pRrelationSet->getRelation(i);
1802 if(accRelation.RelationType == 7)
1803 {
1804 Sequence< Reference< XInterface > > xTargets = accRelation.TargetSet;
1805 return static_cast<XAccessible*>(xTargets[0].get());
1806 }
1807 }
1808 return nullptr;
1809}
1810
1811COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_groupPosition(long __RPC_FAR *groupLevel,long __RPC_FAR *similarItemsInGroup,long __RPC_FAR *positionInGroup)
1812{
1813 SolarMutexGuard g;
1814
1815 try {
1816 if (m_isDestroy) return S_FALSE;
1817 // #CHECK#
1818 if(groupLevel == nullptr || similarItemsInGroup == nullptr || positionInGroup == nullptr)
1819 {
1820 return E_INVALIDARG;
1821 }
1822
1823 if (!m_xAccessible.is())
1824 return E_FAIL;
1825
1826 Reference<XAccessibleContext> const pRContext =
1827 m_xAccessible->getAccessibleContext();
1828 if(!pRContext.is())
1829 return E_FAIL;
1830 long Role = pRContext->getAccessibleRole();
1831
1832 *groupLevel = 0;
1833 *similarItemsInGroup = 0;
1834 *positionInGroup = 0;
1835
1836 if (Role != AccessibleRole::DOCUMENT && Role != AccessibleRole::DOCUMENT_PRESENTATION &&
1837 Role != AccessibleRole::DOCUMENT_SPREADSHEET && Role != AccessibleRole::DOCUMENT_TEXT)
1838 {
1839 Reference< XAccessibleGroupPosition > xGroupPosition( pRContext, UNO_QUERY );
1840 if ( xGroupPosition.is() )
1841 {
1842 Sequence< sal_Int32 > rSeq = xGroupPosition->getGroupPosition( Any( pRContext ) );
1843 if (rSeq.getLength() >= 3)
1844 {
1845 *groupLevel = rSeq[0];
1846 *similarItemsInGroup = rSeq[1];
1847 *positionInGroup = rSeq[2];
1848 return S_OK;
1849 }
1850 return S_OK;
1851 }
1852 }
1853
1854 Reference< XAccessible> pParentAcc = pRContext->getAccessibleParent();
1855 if( !pParentAcc.is() )
1856 {
1857 return S_OK;
1858 }
1859
1860 Reference<XAccessibleContext> pRParentContext = pParentAcc->getAccessibleContext();
1861
1862 if( Role == RADIO_BUTTON )
1863 {
1864 int index = 0;
1865 int number = 0;
1866 Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet();
1867 long nRel = pRrelationSet->getRelationCount();
1868 for(int i=0 ; i<nRel ; i++)
1869 {
1870 AccessibleRelation accRelation = pRrelationSet->getRelation(i);
1871 if(accRelation.RelationType == 7)
1872 {
1873 Sequence< Reference< XInterface > > xTargets = accRelation.TargetSet;
1874
1875 Reference<XInterface> pRAcc = xTargets[0];
1876 sal_Int64 nChildCount = pRParentContext->getAccessibleChildCount();
1877 assert(nChildCount < std::numeric_limits<long>::max());
1878 for (sal_Int64 j = 0; j< nChildCount; j++)
1879 {
1880 if( getTheParentOfMember(pRParentContext->getAccessibleChild(j).get())
1881 == static_cast<XAccessible*>(pRAcc.get()) &&
1882 pRParentContext->getAccessibleChild(j)->getAccessibleContext()->getAccessibleRole() == RADIO_BUTTON)
1883 number++;
1884 if (pRParentContext->getAccessibleChild(j).get() == m_xAccessible.get())
1885 index = number;
1886 }
1887 }
1888 }
1889 *groupLevel = 1;
1890 *similarItemsInGroup = number;
1891 *positionInGroup = index;
1892 return S_OK;
1893 }
1894
1895 else if ( COMBO_BOX == Role )
1896 {
1897 *groupLevel = 1;
1898 *similarItemsInGroup = 0;
1899 *positionInGroup = -1;
1900
1901 if (pRContext->getAccessibleChildCount() != 2)
1902 {
1903 return S_OK;
1904 }
1905 Reference<XAccessible> xList=pRContext->getAccessibleChild(1);
1906 if (!xList.is())
1907 {
1908 return S_OK;
1909 }
1910 Reference<XAccessibleContext> xListContext(xList,UNO_QUERY);
1911 if (!xListContext.is())
1912 {
1913 return S_OK;
1914 }
1915 Reference<XAccessibleSelection> xListSel(xList,UNO_QUERY);
1916 if (!xListSel.is())
1917 {
1918 return S_OK;
1919 }
1920 sal_Int64 nChildCount = xListContext->getAccessibleChildCount();
1921 assert(nChildCount < std::numeric_limits<long>::max());
1922 *similarItemsInGroup = nChildCount;
1923 if (*similarItemsInGroup > 0 )
1924 {
1925 try
1926 {
1927 Reference<XAccessible> xChild = xListSel->getSelectedAccessibleChild(0);
1928 if (xChild.is())
1929 {
1930 Reference<XAccessibleContext> xChildContext(xChild,UNO_QUERY);
1931 if (xChildContext.is())
1932 {
1933 *positionInGroup=xChildContext->getAccessibleIndexInParent() + 1 ;
1934 return S_OK;
1935 }
1936 }
1937 }
1938 catch(...)
1939 {}
1940 }
1941 return S_OK;
1942 }
1943 else if ( PAGE_TAB == Role )
1944 {
1945 *groupLevel = 1;
1946 sal_Int64 nChildCount = pRParentContext->getAccessibleChildCount();
1947 assert(nChildCount < std::numeric_limits<long>::max());
1948 *similarItemsInGroup = nChildCount;
1949 if (*similarItemsInGroup > 0 )
1950 {
1951 *positionInGroup=pRContext->getAccessibleIndexInParent() + 1 ;
1952 }
1953 else
1954 {
1955 *positionInGroup = -1;
1956 }
1957 return S_OK;
1958 }
1959
1960 int level = 0;
1961 bool isFound = false;
1962 while( pParentAcc.is() && !isFound)
1963 {
1964 level++;
1965 pRParentContext = pParentAcc->getAccessibleContext();
1966 Role = pRParentContext->getAccessibleRole();
1967 if( (Role == TREE) || (Role == LIST) )
1968 isFound = true;
1969 pParentAcc = pRParentContext->getAccessibleParent();
1970 }
1971
1972 if( isFound )
1973 {
1974 Reference< XAccessible> pTempAcc = pRContext->getAccessibleParent();
1975 pRParentContext = pTempAcc->getAccessibleContext();
1976 *groupLevel = level;
1977 sal_Int64 nChildCount = pRParentContext->getAccessibleChildCount();
1978 assert(nChildCount < std::numeric_limits<long>::max());
1979 *similarItemsInGroup = nChildCount;
1980 *positionInGroup = pRContext->getAccessibleIndexInParent() + 1;
1981 }
1982 else
1983 {
1984 *groupLevel = 0;
1985 *similarItemsInGroup = 0;
1986 *positionInGroup = 0;
1987 }
1988 return S_OK;
1989
1990 } catch(...) { return E_FAIL; }
1991}
1992
1993COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_extendedStates(long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *)
1994{
1995 return E_NOTIMPL;
1996}
1997
1998
1999COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_uniqueID(long __RPC_FAR *uniqueID)
2000{
2001 SolarMutexGuard g;
2002
2003 try {
2004 if (m_isDestroy) return S_FALSE;
2005 // #CHECK#
2006 if(uniqueID == nullptr)
2007 {
2008 return E_INVALIDARG;
2009 }
2010 *uniqueID = m_dChildID;
2011 return S_OK;
2012
2013 } catch(...) { return E_FAIL; }
2014}
2015
2016COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_windowHandle(HWND __RPC_FAR *windowHandle)
2017{
2018 SolarMutexGuard g;
2019
2020 try {
2021 if (m_isDestroy) return S_FALSE;
2022 // #CHECK#
2023 if(windowHandle == nullptr)
2024 {
2025 return E_INVALIDARG;
2026 }
2027
2028 HWND nHwnd = m_hwnd;
2029 IAccessible* pParent = m_pIParent;
2030 while((nHwnd==nullptr) && pParent)
2031 {
2032 if (CMAccessible* pChild = dynamic_cast<CMAccessible*>(pParent))
2033 {
2034 pParent = pChild->m_pIParent;
2035 nHwnd = pChild->m_hwnd;
2036 }
2037 else
2038 pParent = nullptr;
2039 }
2040
2041 *windowHandle = nHwnd;
2042 return S_OK;
2043
2044 } catch(...) { return E_FAIL; }
2045}
2046
2052XAccessibleContext* CMAccessible::GetContextByXAcc( XAccessible* pXAcc )
2053{
2054 Reference< XAccessibleContext > pRContext;
2055 if( pXAcc == nullptr)
2056 return nullptr;
2057
2058 pRContext = pXAcc->getAccessibleContext();
2059 if( !pRContext.is() )
2060 return nullptr;
2061 return pRContext.get();
2062}
2063
2070COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::SetXAccessible(hyper pXAcc)
2071{
2072 // internal IMAccessible - no mutex meeded
2073
2074 m_xAccessible = reinterpret_cast<XAccessible*>(pXAcc);
2075 m_pEnumVar->PutSelection(/*XAccessibleSelection*/
2076 reinterpret_cast<hyper>(m_xAccessible.get()));
2077
2078 m_xContext = m_xAccessible->getAccessibleContext();
2079
2080 return S_OK;
2081}
2082
2092COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::accSelect(long flagsSelect, VARIANT varChild)
2093{
2094 SolarMutexGuard g;
2095
2096 try {
2097 if (m_isDestroy) return S_FALSE;
2098 if( (flagsSelect&SELFLAG_ADDSELECTION) &&
2099 (SELFLAG_REMOVESELECTION&flagsSelect) )
2100 return E_INVALIDARG;
2101
2102 if ( (flagsSelect&SELFLAG_TAKESELECTION) &&
2103 (
2104 (flagsSelect&SELFLAG_ADDSELECTION) ||
2105 (flagsSelect&SELFLAG_REMOVESELECTION) ||
2106 (flagsSelect&SELFLAG_EXTENDSELECTION )
2107 )
2108 )
2109 return E_INVALIDARG;
2110
2111 if ( varChild.vt != VT_I4 )
2112 return E_INVALIDARG;
2113
2114 IMAccessible* pSelectAcc;
2115 if( varChild.lVal == CHILDID_SELF )
2116 {
2117 pSelectAcc = this;
2118 pSelectAcc->AddRef();
2119 }
2120 else
2121 {
2122 pSelectAcc = GetChildInterface(varChild.lVal);
2123 }
2124
2125 if( pSelectAcc == nullptr )
2126 return E_INVALIDARG;
2127
2128 if( flagsSelect&SELFLAG_TAKEFOCUS )
2129 {
2130 union {
2131 XAccessible* pTempUNO;
2132 hyper nHyper = 0;
2133 };
2134 pSelectAcc->GetUNOInterface(&nHyper);
2135
2136 if( pTempUNO == nullptr )
2137 return 0;
2138
2139 Reference<XAccessibleContext> pRContext = pTempUNO->getAccessibleContext();
2140 Reference< XAccessibleComponent > pRComponent(pRContext,UNO_QUERY);
2141 Reference< XAccessible > pRParentXAcc = pRContext->getAccessibleParent();
2142 Reference< XAccessibleContext > pRParentContext = pRParentXAcc->getAccessibleContext();
2143 Reference< XAccessibleComponent > pRParentComponent(pRParentContext,UNO_QUERY);
2144 Reference< XAccessibleSelection > pRParentSelection(pRParentContext,UNO_QUERY);
2145
2146
2147 pRComponent->grabFocus();
2148
2149 if( flagsSelect & SELFLAG_TAKESELECTION )
2150 {
2151 pRParentSelection->clearAccessibleSelection();
2152 pRParentSelection->selectAccessibleChild( pRContext->getAccessibleIndexInParent() );
2153 }
2154
2155 if( flagsSelect & SELFLAG_ADDSELECTION )
2156 {
2157 pRParentSelection->selectAccessibleChild( pRContext->getAccessibleIndexInParent() );
2158 }
2159
2160 if( flagsSelect & SELFLAG_REMOVESELECTION )
2161 {
2162 pRParentSelection->deselectAccessibleChild( pRContext->getAccessibleIndexInParent() );
2163 }
2164
2165 if( flagsSelect & SELFLAG_EXTENDSELECTION )
2166 {
2167 sal_Int64 indexInParrent = pRContext->getAccessibleIndexInParent();
2168
2169 if( pRParentSelection->isAccessibleChildSelected( indexInParrent + 1 ) ||
2170 pRParentSelection->isAccessibleChildSelected( indexInParrent - 1 ) )
2171 {
2172 pRParentSelection->selectAccessibleChild( indexInParrent );
2173 }
2174 }
2175
2176 }
2177
2178 pSelectAcc->Release();
2179 return S_OK;
2180
2181 } catch(...) { return E_FAIL; }
2182}
2183
2189COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::GetUNOInterface(hyper * pXAcc)
2190{
2191 // internal IMAccessible - no mutex meeded
2192
2193 if(pXAcc == nullptr)
2194 return E_INVALIDARG;
2195
2196 *pXAcc = reinterpret_cast<hyper>(m_xAccessible.get());
2197 return S_OK;
2198}
2199
2205COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::SetDefaultAction(hyper pAction)
2206{
2207 // internal IMAccessible - no mutex meeded
2208
2209 m_xAction = reinterpret_cast<XAccessibleAction*>(pAction);
2210 return S_OK;
2211}
2212
2220COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE CMAccessible::get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction)
2221{
2222 SolarMutexGuard g;
2223
2224 try {
2225 if (m_isDestroy) return S_FALSE;
2226 // #CHECK#
2227 if(pszDefaultAction == nullptr)
2228 {
2229 return E_INVALIDARG;
2230 }
2231 if(varChild.vt==VT_I4)
2232 {
2233 if(varChild.lVal==CHILDID_SELF)
2234 {
2235 if (!m_xAction.is())
2236 return DISP_E_MEMBERNOTFOUND;
2237 SysFreeString(*pszDefaultAction);
2238 *pszDefaultAction = SysAllocString(m_pszActionDescription);
2239 return S_OK;
2240 }
2241
2242 long lVal = varChild.lVal;
2243 varChild.lVal = CHILDID_SELF;
2244 IMAccessible *pChild = this->GetChildInterface(lVal);
2245 if(!pChild)
2246 return E_FAIL;
2247 return pChild->get_accDefaultAction(varChild,pszDefaultAction);
2248 }
2249 return S_FALSE;
2250
2251 } catch(...) { return E_FAIL; }
2252}
2253
2259COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE CMAccessible::accDoDefaultAction(VARIANT varChild)
2260{
2261 SolarMutexGuard g;
2262
2263 try {
2264 if (m_isDestroy) return S_FALSE;
2265 if( varChild.vt != VT_I4 )
2266 return E_INVALIDARG;
2267 if (!m_xAction.is())
2268 return E_FAIL;
2269 if (m_xAction->getAccessibleActionCount() == 0)
2270 return E_FAIL;
2271
2272 if(varChild.lVal==CHILDID_SELF)
2273 {
2274 if (m_xAction->getAccessibleActionCount() > 0)
2275 m_xAction->doAccessibleAction(0);
2276 return S_OK;
2277 }
2278
2279 long lVal = varChild.lVal;
2280 varChild.lVal = CHILDID_SELF;
2281 IMAccessible *pChild = this->GetChildInterface(lVal);
2282 if(!pChild)
2283 return E_FAIL;
2284 return pChild->accDoDefaultAction( varChild );
2285
2286 } catch(...) { return E_FAIL; }
2287}
2288
2294COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::Put_ActionDescription( const OLECHAR* szAction)
2295{
2296 // internal IMAccessible - no mutex meeded
2297
2298 try {
2299 if (m_isDestroy) return S_FALSE;
2300 // #CHECK#
2301 if(szAction == nullptr)
2302 {
2303 return E_INVALIDARG;
2304 }
2305 SysFreeString(m_pszActionDescription );
2306 m_pszActionDescription = SysAllocString( szAction );
2307 return S_OK;
2308
2309 } catch(...) { return E_FAIL; }
2310}
2311
2312bool CMAccessible::GetXInterfaceFromXAccessible(XAccessible* pXAcc, XInterface** ppXI, XInterfaceType eType)
2313{
2314 switch(eType)
2315 {
2316 case XInterfaceType::XI_COMPONENT:
2317 return queryXInterface<XAccessibleComponent>(pXAcc, ppXI);
2318 case XInterfaceType::XI_TEXT:
2319 return queryXInterface<XAccessibleText>(pXAcc, ppXI);
2320 case XInterfaceType::XI_EDITABLETEXT:
2321 return queryXInterface<XAccessibleEditableText>(pXAcc, ppXI);
2322 case XInterfaceType::XI_TABLE:
2323 return queryXInterface<XAccessibleTable>(pXAcc, ppXI);
2324 case XInterfaceType::XI_TABLECELL:
2325 // needs specific handling, since there's no XInterface for table cells
2326 return queryTableCell(pXAcc, ppXI);
2327 case XInterfaceType::XI_SELECTION:
2328 return queryXInterface<XAccessibleSelection>(pXAcc, ppXI);
2329 case XInterfaceType::XI_EXTENDEDCOMP:
2330 return queryXInterface<XAccessibleExtendedComponent>(pXAcc, ppXI);
2331 case XInterfaceType::XI_KEYBINDING:
2332 return queryXInterface<XAccessibleKeyBinding>(pXAcc, ppXI);
2333 case XInterfaceType::XI_ACTION:
2334 return queryXInterface<XAccessibleAction>(pXAcc, ppXI);
2335 case XInterfaceType::XI_VALUE:
2336 return queryXInterface<XAccessibleValue>(pXAcc, ppXI);
2337 case XInterfaceType::XI_HYPERTEXT:
2338 return queryXInterface<XAccessibleHypertext>(pXAcc, ppXI);
2339 case XInterfaceType::XI_HYPERLINK:
2340 return queryXInterface<XAccessibleHyperlink>(pXAcc, ppXI);
2341 case XInterfaceType::XI_IMAGE:
2342 return queryXInterface<XAccessibleImage>(pXAcc, ppXI);
2343 default:
2344 return false;
2345 }
2346}
2347
2348template<typename T> static HRESULT
2349createAggInstance(CMAccessible &rOuter, void ** ppvObject)
2350{
2351 // Note: CComAggObject has special handling for IUnknown - must
2352 // query for that when creating it! Otherwise we get a T member of it
2353 // which will redirect QueryInterface back to CMAccessible infinitely.
2354 // (CComAggObject has its own ref-count too which is not a problem
2355 // since it is inserted in m_containedObjects.)
2356 return CComCreator< CComAggObject<T> >::CreateInstance(
2357 rOuter.GetControllingUnknown(), IID_IUnknown, ppvObject);
2358}
2359
2360typedef HRESULT (AggCreatorFunc)(CMAccessible &, void **);
2361
2362namespace {
2363
2364struct AggMapEntry
2365{
2366 const IID* piid;
2367 AggCreatorFunc* pfnCreateInstance;
2368 const XInterfaceType eXInterfaceType;
2369};
2370
2371}
2372
2373static AggMapEntry g_CMAccessible_AggMap[] = {
2374 { &IID_IAccessibleComponent, &createAggInstance<CAccComponent>, XInterfaceType::XI_COMPONENT },
2375 { &IID_IAccessibleText, &createAggInstance<CAccText>, XInterfaceType::XI_TEXT },
2376 { &IID_IAccessibleEditableText, &createAggInstance<CAccEditableText>, XInterfaceType::XI_EDITABLETEXT },
2377 { &IID_IAccessibleImage, &createAggInstance<CAccImage>, XInterfaceType::XI_IMAGE },
2378 { &IID_IAccessibleTable, &createAggInstance<CAccTable>, XInterfaceType::XI_TABLE },
2379 { &IID_IAccessibleTable2, &createAggInstance<CAccTable>, XInterfaceType::XI_TABLE },
2380 { &IID_IAccessibleTableCell, &createAggInstance<CAccTableCell>, XInterfaceType::XI_TABLECELL },
2381 { &IID_IAccessibleAction, &createAggInstance<CAccAction>, XInterfaceType::XI_ACTION },
2382 { &IID_IAccessibleValue, &createAggInstance<CAccValue>, XInterfaceType::XI_VALUE },
2383 { &IID_IAccessibleHypertext, &createAggInstance<CAccHypertext>, XInterfaceType::XI_HYPERTEXT },
2384 { &IID_IAccessibleHyperlink, &createAggInstance<CAccHyperLink>, XInterfaceType::XI_HYPERLINK }
2385};
2386
2387
2388HRESULT WINAPI CMAccessible::SmartQI(void* /*pv*/, REFIID iid, void** ppvObject)
2389{
2390 try {
2391
2392 if (m_isDestroy) return S_FALSE;
2393 if (InlineIsEqualGUID(iid,IID_IAccIdentity) ||
2394 InlineIsEqualGUID(iid,IID_IStdMarshalInfo) ||
2395 InlineIsEqualGUID(iid,IID_IMarshal) ||
2396 InlineIsEqualGUID(iid,IID_IExternalConnection)||
2397 InlineIsEqualGUID(iid,IID_IOleWindow))
2398 {
2399 return E_FAIL;
2400 }
2401
2402 for (const AggMapEntry& rEntry : g_CMAccessible_AggMap)
2403 {
2404 if (InlineIsEqualGUID(iid, *rEntry.piid))
2405 {
2406 SolarMutexGuard g;
2407
2408 XInterface* pXI = nullptr;
2409 bool bFound = GetXInterfaceFromXAccessible(m_xAccessible.get(),
2410 &pXI, rEntry.eXInterfaceType);
2411 if(!bFound)
2412 {
2413 return E_FAIL;
2414 }
2415
2416 XGUIDToComObjHash::iterator pIndTemp = m_containedObjects.find( iid );
2417 if ( pIndTemp != m_containedObjects.end() )
2418 {
2419 return pIndTemp->second.p->QueryInterface( iid, ppvObject );
2420 }
2421 else
2422 {
2423 HRESULT hr = rEntry.pfnCreateInstance(*this, ppvObject);
2424 assert(hr == S_OK);
2425 if(hr == S_OK)
2426 {
2427 m_containedObjects.emplace(*rEntry.piid, static_cast<IUnknown*>(*ppvObject));
2428 IUNOXWrapper* wrapper = nullptr;
2429 static_cast<IUnknown*>(*ppvObject)->QueryInterface(IID_IUNOXWrapper, reinterpret_cast<void**>(&wrapper));
2430 if(wrapper)
2431 {
2432 wrapper->put_XInterface(
2433 reinterpret_cast<hyper>(m_xAccessible.get()));
2434 wrapper->Release();
2435 }
2436 return S_OK;
2437 }
2438 }
2439 return E_FAIL;
2440 }
2441 }
2442 return E_FAIL;
2443
2444 } catch(...) { return E_FAIL; }
2445}
2446
2447bool CMAccessible::get_IAccessibleFromXAccessible(XAccessible* pXAcc, IAccessible** ppIA)
2448{
2449 try
2450 {
2451 // #CHECK#
2452 if(ppIA == nullptr)
2453 {
2454 return false;
2455 }
2456 bool isGet = false;
2457 if(g_pAgent)
2458 isGet = g_pAgent->GetIAccessibleFromXAccessible(pXAcc, ppIA);
2459
2460 return isGet;
2461 }
2462 catch(...)
2463 {
2464 return false;
2465 }
2466}
2467
2468OUString CMAccessible::get_StringFromAny(Any const & pAny)
2469{
2470 switch(pAny.getValueTypeClass())
2471 {
2472 case TypeClass_CHAR:
2473 {
2474 sal_Int8 val;
2475 pAny >>= val;
2476 return OUString::number(val);
2477 }
2478 case TypeClass_BOOLEAN:
2479 {
2480 bool val;
2481 pAny >>= val;
2482 return OUString::number(int(val));
2483 }
2484 case TypeClass_BYTE:
2485 {
2486 sal_Int8 val;
2487 pAny >>= val;
2488 return OUString::number(val);
2489 }
2490 case TypeClass_SHORT:
2491 {
2492 sal_Int16 val;
2493 pAny >>= val;
2494 return OUString::number(val);
2495 }
2496 case TypeClass_UNSIGNED_SHORT:
2497 {
2498 sal_uInt16 val;
2499 pAny >>= val;
2500 return OUString::number(val);
2501 }
2502 case TypeClass_LONG:
2503 {
2504 sal_Int32 val;
2505 pAny >>= val;
2506 return OUString::number(val);
2507 }
2508 case TypeClass_UNSIGNED_LONG:
2509 {
2510 sal_uInt32 val;
2511 pAny >>= val;
2512 return OUString::number(val);
2513 }
2514 case TypeClass_FLOAT:
2515 {
2516 float val;
2517 pAny >>= val;
2518 return OUString::number(val);
2519 }
2520 case TypeClass_DOUBLE:
2521 {
2522 double val;
2523 pAny >>= val;
2524 return OUString::number(val);
2525 }
2526 case TypeClass_STRING:
2527 {
2528 OUString val;
2529 pAny >>= val;
2530 return val;
2531 }
2532 case TypeClass_SEQUENCE:
2533 {
2534 if(pAny.getValueType() == cppu::UnoType<Sequence< OUString >>::get())
2535 {
2536 Sequence < OUString > val;
2537 pAny >>= val;
2538
2539 OUStringBuffer pString;
2540
2541 for (const OUString& rElem : val)
2542 pString.append(rElem);
2543
2544 return pString.makeStringAndClear();
2545 }
2546 else if (pAny.getValueType() == cppu::UnoType<Sequence< css::style::TabStop >>::get())
2547 {
2548 Sequence < css::style::TabStop > val;
2549 pAny >>= val;
2550
2551 OUStringBuffer buf;
2552 for (const css::style::TabStop& rSingleVal : val)
2553 {
2554 buf.append(
2555 "Position=" + OUString::number(rSingleVal.Position) + ",TabAlign="
2556 + OUString::number(sal_Int32(rSingleVal.Alignment)) + ",DecimalChar=");
2557 if (rSingleVal.DecimalChar==';' || rSingleVal.DecimalChar == ':' || rSingleVal.DecimalChar == ',' ||
2558 rSingleVal.DecimalChar == '=' || rSingleVal.DecimalChar == '\\')
2559 buf.append('\\');
2560 buf.append(OUStringChar(rSingleVal.DecimalChar) + ",FillChar=");
2561 if (rSingleVal.FillChar==';' || rSingleVal.FillChar == ':' || rSingleVal.FillChar == ',' ||
2562 rSingleVal.FillChar == '=' || rSingleVal.FillChar == '\\')
2563 buf.append('\\');
2564 buf.append(OUStringChar(rSingleVal.FillChar) + ",");
2565 }
2566 return buf.makeStringAndClear();
2567 }
2568 break;
2569 }
2570 case TypeClass_ENUM:
2571 {
2572 if (pAny.getValueType() == cppu::UnoType<css::awt::FontSlant>::get())
2573 {
2574 css::awt::FontSlant val;
2575 pAny >>= val;
2576 return OUString::number(sal_Int32(val));
2577 }
2578 break;
2579 }
2580 case TypeClass_STRUCT:
2581 {
2582 if (pAny.getValueType() == cppu::UnoType<css::style::LineSpacing>::get())
2583 {
2584 css::style::LineSpacing val;
2585 pAny >>= val;
2586 return "Mode=" + OUString::number(val.Mode) + ",Height="
2587 + OUString::number(val.Height) + ",";
2588 }
2589 else if (pAny.getValueType() == cppu::UnoType<css::accessibility::TextSegment>::get())
2590 {
2591 css::accessibility::TextSegment val;
2592 pAny >>= val;
2593 return val.SegmentText;
2594 }
2595 break;
2596 }
2597 case TypeClass_VOID:
2598 case TypeClass_HYPER:
2599 case TypeClass_UNSIGNED_HYPER:
2600 case TypeClass_TYPE:
2601 case TypeClass_ANY:
2602 case TypeClass_TYPEDEF:
2603 case TypeClass_EXCEPTION:
2604 case TypeClass_INTERFACE:
2605 case TypeClass_SERVICE:
2606 case TypeClass_MODULE:
2607 case TypeClass_INTERFACE_METHOD:
2608 case TypeClass_INTERFACE_ATTRIBUTE:
2609 case TypeClass_UNKNOWN:
2610 case TypeClass_PROPERTY:
2611 case TypeClass_CONSTANT:
2612 case TypeClass_CONSTANTS:
2613 case TypeClass_SINGLETON:
2614 break;
2615 default:
2616 break;
2617 }
2618 return OUString();
2619}
2620
2621OUString CMAccessible::get_String4Numbering(const Any& pAny, sal_Int16 numberingLevel,std::u16string_view numberingPrefix)
2622{
2623 Reference< css::container::XIndexReplace > pXIndex;
2624 if((pAny>>=pXIndex) && (numberingLevel !=-1))//numbering level is -1,means invalid value
2625 {
2626 Any aAny = pXIndex->getByIndex(numberingLevel);
2627 Sequence< css::beans::PropertyValue > aProps;
2628 aAny >>= aProps;
2629 OUStringBuffer buf("Numbering:NumberingLevel=" + OUString::number(numberingLevel) + ",");
2630 for (const css::beans::PropertyValue& rProp : aProps)
2631 {
2632 if( (rProp.Name == "BulletChar" ) ||
2633 (rProp.Name == "NumberingType" ))
2634 {
2635 buf.append(rProp.Name + "=");
2636 auto const pTemp = CMAccessible::get_StringFromAny(rProp.Value);
2637 buf.append(pTemp + ",");
2638
2639 if (rProp.Name == "NumberingType" && !numberingPrefix.empty())
2640 {
2641 buf.append(OUString::Concat("NumberingPrefix=") + numberingPrefix);
2642 }
2643 }
2644 }
2645 return buf.makeStringAndClear();
2646 }
2647
2648 //Because now have three types numbering level:
2649 //1.real numbering list,numbering level>=0 and numbering Rule !=NULL;
2650 //2.common paragraph, numbering level >=0, and numbering Rule == NULL;
2651 //3.TOC paragraph, numbering level >0, and numbering Rule ==NULL;
2652 // IAText:numberinglevel base on 0, but TOC's level base on 1,
2653 // so NumberingLevel value will be decreased 1 in bridge code.
2654 else if(numberingLevel >0)
2655 {
2656 return "Numbering:NumberingLevel=" + OUString::number(numberingLevel-1) + ",NumberingType=4,NumberingPrefix=,";
2657 }
2658 else
2659 {
2660 return "Numbering:";
2661 }
2662}
2663
2664void CMAccessible::ConvertAnyToVariant(const css::uno::Any &rAnyVal, VARIANT *pvData)
2665{
2666 if(rAnyVal.hasValue())
2667 {
2668 // Clear VARIANT variable.
2669 VariantClear(pvData);
2670
2671 // Set value according to value type.
2672 switch(rAnyVal.getValueTypeClass())
2673 {
2674 case TypeClass_CHAR:
2675 pvData->vt = VT_UI1;
2676 memcpy(&pvData->bVal, rAnyVal.getValue(), sizeof(char));
2677 break;
2678
2679 case TypeClass_BOOLEAN:
2680 {
2681 bool bBoolean(false);
2682 rAnyVal >>= bBoolean;
2683 pvData->vt = VT_BOOL;
2684 pvData->boolVal = VARIANT_BOOL(bBoolean); // boolVal is a VARIANT_BOOL, a 16bit field
2685 break;
2686 }
2687 case TypeClass_BYTE:
2688 pvData->vt = VT_UI1;
2689 memcpy(&pvData->bVal, rAnyVal.getValue(), sizeof(sal_Int8));
2690 break;
2691
2692 case TypeClass_SHORT:
2693 pvData->vt = VT_I2;
2694 memcpy(&pvData->iVal, rAnyVal.getValue(), sizeof(sal_Int16));
2695 break;
2696
2697 case TypeClass_UNSIGNED_SHORT:
2698 pvData->vt = VT_I2;
2699 memcpy(&pvData->iVal, rAnyVal.getValue(), sizeof(sal_uInt16));
2700 break;
2701
2702 case TypeClass_LONG:
2703 pvData->vt = VT_I4;
2704 memcpy(&pvData->lVal, rAnyVal.getValue(), sizeof(sal_Int32));
2705 break;
2706
2707 case TypeClass_UNSIGNED_LONG:
2708 pvData->vt = VT_I4;
2709 memcpy(&pvData->lVal, rAnyVal.getValue(), sizeof(sal_uInt32));
2710 break;
2711
2712 case TypeClass_FLOAT:
2713 pvData->vt = VT_R4;
2714 memcpy(&pvData->fltVal, rAnyVal.getValue(), sizeof(float));
2715 break;
2716
2717 case TypeClass_DOUBLE:
2718 pvData->vt = VT_R8;
2719 memcpy(&pvData->dblVal, rAnyVal.getValue(), sizeof(double));
2720 break;
2721
2722 case TypeClass_STRING:
2723 {
2724 pvData->vt = VT_BSTR;
2725 OUString val;
2726 rAnyVal >>= val;
2727 pvData->bstrVal = SysAllocString(o3tl::toW(val.getStr()));
2728 break;
2729 }
2730
2731 case TypeClass_VOID:
2732 case TypeClass_HYPER:
2733 case TypeClass_UNSIGNED_HYPER:
2734 case TypeClass_TYPE:
2735 case TypeClass_ANY:
2736 case TypeClass_ENUM:
2737 case TypeClass_TYPEDEF:
2738 case TypeClass_STRUCT:
2739 case TypeClass_EXCEPTION:
2740 case TypeClass_SEQUENCE:
2741 case TypeClass_INTERFACE:
2742 {
2743 Reference< XAccessible > pXAcc;
2744 if(rAnyVal >>= pXAcc)
2745 {
2746 if(pXAcc.is())
2747 {
2748 IAccessible* pIAcc = nullptr;
2749 get_IAccessibleFromXAccessible(pXAcc.get(), &pIAcc);
2750 if(pIAcc == nullptr)
2751 {
2752 Reference< XAccessibleContext > pXAccContext = pXAcc->getAccessibleContext();
2753 g_pAgent->InsertAccObj(pXAcc.get(),pXAccContext->getAccessibleParent().get());
2754 get_IAccessibleFromXAccessible(pXAcc.get(), &pIAcc);
2755 }
2756 if(pIAcc)
2757 {
2758 pIAcc->AddRef();
2759
2760 pvData->vt = VT_UNKNOWN;
2761 pvData->pdispVal = pIAcc;
2762 break;
2763 }
2764 }
2765 }
2766 [[fallthrough]];
2767 }
2768 case TypeClass_SERVICE:
2769 case TypeClass_MODULE:
2770 case TypeClass_INTERFACE_METHOD:
2771 case TypeClass_INTERFACE_ATTRIBUTE:
2772 case TypeClass_UNKNOWN:
2773 case TypeClass_PROPERTY:
2774 case TypeClass_CONSTANT:
2775 case TypeClass_CONSTANTS:
2776 case TypeClass_SINGLETON:
2777 case TypeClass::TypeClass_MAKE_FIXED_SIZE:
2778 // Output the type string, if there is other uno value type.
2779 pvData->vt = VT_BSTR;
2780 pvData->bstrVal = SysAllocString(o3tl::toW(rAnyVal.getValueTypeName().getStr()));
2781 break;
2782
2783 default:
2784 break;
2785 }
2786 }
2787 else
2788 {
2789 VariantClear(pvData);
2790 }
2791}
2792
2793COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_states(AccessibleStates __RPC_FAR *states)
2794{
2795 SolarMutexGuard g;
2796
2797 try {
2798 if (m_isDestroy) return S_FALSE;
2799
2800 if (!m_xContext.is())
2801 return E_FAIL;
2802
2803 sal_Int64 const nRStateSet =
2804 m_xContext->getAccessibleStateSet();
2805
2806 *states = 0x0;
2807 for( std::size_t j = 0; j < SAL_N_ELEMENTS(UNO_STATES); j++ )
2808 {
2809 if( (UNO_STATES[j] != -1) && (nRStateSet & UNO_STATES[j]) )
2810 {
2811 *states |= IA2_STATES[j];
2812 }
2813 }
2814 return S_OK;
2815
2816
2817 } catch(...) { return E_FAIL; }
2818}
2819
2820// return the UNO roles
2821COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_extendedRole(BSTR __RPC_FAR *)
2822{
2823 return E_NOTIMPL;
2824}
2825
2826COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_localizedExtendedRole(BSTR __RPC_FAR *)
2827{
2828 return E_NOTIMPL;
2829}
2830
2831COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_nExtendedStates(long __RPC_FAR *)
2832{
2833 return E_NOTIMPL;
2834}
2835
2836
2837COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_localizedExtendedStates(long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *)
2838{
2839 return E_NOTIMPL;
2840}
2841
2842
2843COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_indexInParent(long __RPC_FAR *accParentIndex)
2844{
2845 try {
2846 if (m_isDestroy) return S_FALSE;
2847 // #CHECK#
2848 if(accParentIndex == nullptr)
2849 return E_INVALIDARG;
2850
2851 if (!m_xContext.is())
2852 return E_FAIL;
2853
2854 sal_Int64 nIndex = m_xContext->getAccessibleIndexInParent();
2855 if (nIndex > std::numeric_limits<long>::max())
2856 {
2857 SAL_WARN("iacc2", "CMAccessible::get_indexInParent: Child index exceeds maximum long value, "
2858 "returning max long.");
2859 nIndex = std::numeric_limits<long>::max();
2860 }
2861 *accParentIndex = nIndex;
2862 return S_OK;
2863
2864
2865 } catch(...) { return E_FAIL; }
2866}
2867COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_locale( IA2Locale __RPC_FAR *locale )
2868{
2869 try {
2870 if (m_isDestroy) return S_FALSE;
2871 if(locale == nullptr)
2872 return E_INVALIDARG;
2873
2874 if (!m_xContext.is())
2875 return E_FAIL;
2876
2877 css::lang::Locale unoLoc = m_xContext->getLocale();
2878 locale->language = SysAllocString(o3tl::toW(unoLoc.Language.getStr()));
2879 locale->country = SysAllocString(o3tl::toW(unoLoc.Country.getStr()));
2880 locale->variant = SysAllocString(o3tl::toW(unoLoc.Variant.getStr()));
2881
2882 return S_OK;
2883
2884 } catch(...) { return E_FAIL; }
2885}
2886
2887COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_appName(BSTR __RPC_FAR *name)
2888{
2889 SolarMutexGuard g;
2890
2891 try {
2892 if (m_isDestroy) return S_FALSE;
2893 if(name == nullptr)
2894 return E_INVALIDARG;
2895
2896 static const OUString sAppName = utl::ConfigManager::getProductName();
2897 *name = SysAllocString(o3tl::toW(sAppName.getStr()));
2898 return S_OK;
2899 } catch(...) { return E_FAIL; }
2900}
2901COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_appVersion(BSTR __RPC_FAR *version)
2902{
2903 SolarMutexGuard g;
2904
2905 try {
2906 if (m_isDestroy) return S_FALSE;
2907 if(version == nullptr)
2908 return E_INVALIDARG;
2909 static const OUString sVersion = utl::ConfigManager::getProductVersion();
2910 *version=SysAllocString(o3tl::toW(sVersion.getStr()));
2911 return S_OK;
2912 } catch(...) { return E_FAIL; }
2913}
2914COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_toolkitName(BSTR __RPC_FAR *name)
2915{
2916 SolarMutexGuard g;
2917
2918 try {
2919 if (m_isDestroy) return S_FALSE;
2920 if(name == nullptr)
2921 return E_INVALIDARG;
2922 *name = SysAllocString(OLESTR("VCL"));
2923 return S_OK;
2924 } catch(...) { return E_FAIL; }
2925}
2926COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_toolkitVersion(BSTR __RPC_FAR *version)
2927{
2928 return get_appVersion(version);
2929}
2930
2931
2932COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_attributes(/*[out]*/ BSTR *pAttr)
2933{
2934 SolarMutexGuard g;
2935
2936 try {
2937 if (m_isDestroy) return S_FALSE;
2938
2939 if (!m_xAccessible.is())
2940 return E_FAIL;
2941
2942 Reference<XAccessibleContext> pRContext = m_xAccessible->getAccessibleContext();
2943 if( !pRContext.is() )
2944 {
2945 return E_FAIL;
2946 }
2947 Reference<XAccessibleExtendedAttributes> pRXI(pRContext,UNO_QUERY);
2948 if( !pRXI.is() )
2949 return E_FAIL;
2950 else
2951 {
2952 css::uno::Reference<css::accessibility::XAccessibleExtendedAttributes> pRXAttr;
2953 pRXAttr = pRXI.get();
2954 css::uno::Any anyVal = pRXAttr->getExtendedAttributes();
2955
2956 OUString val;
2957 anyVal >>= val;
2958
2959 if(*pAttr)
2960 SysFreeString(*pAttr);
2961 *pAttr = SysAllocString(o3tl::toW(val.getStr()));
2962
2963 return S_OK;
2964 }
2965 } catch(...) { return E_FAIL; }
2966}
2967
2968/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
IA2_STATES
long const IA2_STATES[]
Definition: MAccessible.cxx:134
getTheParentOfMember
static XAccessible * getTheParentOfMember(XAccessible *pXAcc)
Definition: MAccessible.cxx:1789
AggCreatorFunc
HRESULT() AggCreatorFunc(CMAccessible &, void **)
Definition: MAccessible.cxx:2360
UNO_STATES
sal_Int64 const UNO_STATES[]
Definition: MAccessible.cxx:156
g_CMAccessible_AggMap
static AggMapEntry g_CMAccessible_AggMap[]
Definition: MAccessible.cxx:2373
GetMnemonicChar
static bool GetMnemonicChar(const OUString &aStr, sal_Unicode *wStr)
Definition: MAccessible.cxx:608
createAggInstance
static HRESULT createAggInstance(CMAccessible &rOuter, void **ppvObject)
Definition: MAccessible.cxx:2349
DM_FIRSTCHILD
@ DM_FIRSTCHILD
Definition: acccommon.h:48
DM_LASTCHILD
@ DM_LASTCHILD
Definition: acccommon.h:49
DM_NEXTCHILD
@ DM_NEXTCHILD
Definition: acccommon.h:50
DM_PREVCHILD
@ DM_PREVCHILD
Definition: acccommon.h:51
AccessibleStates
AccessibleStates
char16_t2wchar_t.hxx
AccObjectManagerAgent::GetIAccessibleFromResID
virtual void GetIAccessibleFromResID(long childID, IMAccessible **)
Return com object interface by querying child id.
Definition: AccObjectManagerAgent.cxx:260
AccObjectManagerAgent::GetIAccessibleFromXAccessible
virtual bool GetIAccessibleFromXAccessible(css::accessibility::XAccessible *pXAcc, IAccessible **ppIA)
Return object interface by querying interface.
Definition: AccObjectManagerAgent.cxx:271
AccObjectManagerAgent::GetIMAccByXAcc
virtual IMAccessible * GetIMAccByXAcc(css::accessibility::XAccessible *pXAcc)
Return com object interface by querying XAccessible interface.
Definition: AccObjectManagerAgent.cxx:236
AccObjectManagerAgent::InsertAccObj
virtual bool InsertAccObj(css::accessibility::XAccessible *pXAcc, css::accessibility::XAccessible *pParentXAcc, HWND hWnd=nullptr)
When a new UNO XAccessible object is found by listener, we create a corresponding com object and inse...
Definition: AccObjectManagerAgent.cxx:107
CEnumVariant::PutSelection
HRESULT STDMETHODCALLTYPE PutSelection(hyper pXSelection) override
Put valid UNO XAccessible interface.
Definition: EnumVariant.cxx:252
CEnumVariant::Next
HRESULT STDMETHODCALLTYPE Next(ULONG cElements, VARIANT __RPC_FAR *pvar, ULONG __RPC_FAR *pcElementFetched) override
enumerate method,get next element
Definition: EnumVariant.cxx:42
CEnumVariant::Clone
HRESULT STDMETHODCALLTYPE Clone(IEnumVARIANT __RPC_FAR *__RPC_FAR *ppenum) override
create a new IEnumVariant object, copy current enumaration container and its state to the new object ...
Definition: EnumVariant.cxx:147
CEnumVariant::GetCountOfElements
long GetCountOfElements()
Return count of elements in current container.
Definition: EnumVariant.cxx:195
CEnumVariant::Create
static HRESULT STDMETHODCALLTYPE Create(CEnumVariant __RPC_FAR *__RPC_FAR *ppenum)
Static public method to create a CLSID_EnumVariant com object.
Definition: EnumVariant.cxx:177
CEnumVariant::Reset
HRESULT STDMETHODCALLTYPE Reset(void) override
reset the enumaration position to initial value
Definition: EnumVariant.cxx:130
CMAccessible
This class implements IMAccessible interface, which inherits from IAccessible2, and in turn inherits ...
Definition: MAccessible.h:50
CMAccessible::m_xAction
css::uno::Reference< css::accessibility::XAccessibleAction > m_xAction
Definition: MAccessible.h:182
CMAccessible::role
STDMETHOD() role(long __RPC_FAR *role) override
Definition: MAccessible.cxx:1734
CMAccessible::get_relation
STDMETHOD() get_relation(long relationIndex, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation) override
Definition: MAccessible.cxx:1611
CMAccessible::get_accName
STDMETHOD() get_accName(VARIANT varChild, BSTR *pszName) override
Returns the accessible name of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:351
CMAccessible::get_StringFromAny
static OUString get_StringFromAny(css::uno::Any const &pAny)
Definition: MAccessible.cxx:2468
CMAccessible::m_pEnumVar
CEnumVariant * m_pEnumVar
Definition: MAccessible.h:174
CMAccessible::Put_XAccWindowHandle
STDMETHOD() Put_XAccWindowHandle(HWND hwnd) override
Set the HWND value of the current COM object self from UNO.
Definition: MAccessible.cxx:1188
CMAccessible::get_states
STDMETHOD() get_states(AccessibleStates __RPC_FAR *states) override
Definition: MAccessible.cxx:2793
CMAccessible::get_IAccessibleFromXAccessible
static bool get_IAccessibleFromXAccessible(css::accessibility::XAccessible *pXAcc, IAccessible **ppIA)
Definition: MAccessible.cxx:2447
CMAccessible::get_accKeyboardShortcut
STDMETHOD() get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut) override
Returns the accessible keyboard shortcut of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:630
CMAccessible::SetState
STDMETHOD() SetState(DWORD pXSate) override
Set state into the current state set for the current COM object from UNO.
Definition: MAccessible.cxx:1149
CMAccessible::get_nRelations
STDMETHOD() get_nRelations(long __RPC_FAR *nRelations) override
For IAccessible2 implementation methods.
Definition: MAccessible.cxx:1580
CMAccessible::get_accFocus
STDMETHOD() get_accFocus(VARIANT *pvarChild) override
Returns the current focused child to AT.
Definition: MAccessible.cxx:783
CMAccessible::get_appName
STDMETHOD() get_appName(BSTR __RPC_FAR *name) override
Definition: MAccessible.cxx:2887
CMAccessible::get_accHelp
STDMETHOD() get_accHelp(VARIANT varChild, BSTR *pszHelp) override
Returns the accessible helpString of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:589
CMAccessible::get_nExtendedStates
STDMETHOD() get_nExtendedStates(long __RPC_FAR *nExtendedStates) override
Definition: MAccessible.cxx:2831
CMAccessible::get_localizedExtendedStates
STDMETHOD() get_localizedExtendedStates(long maxLocalizedExtendedStates, BSTR __RPC_FAR *__RPC_FAR *localizedExtendedStates, long __RPC_FAR *nLocalizedExtendedStates) override
Definition: MAccessible.cxx:2837
CMAccessible::m_dState
DWORD m_dState
Definition: MAccessible.h:160
CMAccessible::m_xAccessible
css::uno::Reference< css::accessibility::XAccessible > m_xAccessible
Definition: MAccessible.h:179
CMAccessible::get_locale
STDMETHOD() get_locale(IA2Locale __RPC_FAR *locale) override
Definition: MAccessible.cxx:2867
CMAccessible::GetLastChild
HRESULT GetLastChild(VARIANT varStart, VARIANT *pvarEndUpAt)
Return last child for parent container, process differently according to whether it is descendant man...
Definition: MAccessible.cxx:1472
CMAccessible::Put_XAccChildID
STDMETHOD() Put_XAccChildID(long dChildID) override
Set unique child id to COM.
Definition: MAccessible.cxx:1257
CMAccessible::m_pIParent
IMAccessible * m_pIParent
Definition: MAccessible.h:161
CMAccessible::DecreaseState
STDMETHOD() DecreaseState(DWORD pXSate) override
Add one state into the current state set for the current COM object from UNO.
Definition: MAccessible.cxx:1123
CMAccessible::GetPreSibling
HRESULT GetPreSibling(VARIANT varStart, VARIANT *pvarEndUpAt)
the method GetPreSibling is general, whatever it is descendant manage or not
Definition: MAccessible.cxx:1543
CMAccessible::get_appVersion
STDMETHOD() get_appVersion(BSTR __RPC_FAR *version) override
Definition: MAccessible.cxx:2901
CMAccessible::scrollToPoint
STDMETHOD() scrollToPoint(enum IA2CoordinateType coordinateType, long x, long y) override
Definition: MAccessible.cxx:1779
CMAccessible::g_pAgent
static AccObjectManagerAgent * g_pAgent
Definition: MAccessible.h:207
CMAccessible::m_isDestroy
bool m_isDestroy
Definition: MAccessible.h:177
CMAccessible::get_indexInParent
STDMETHOD() get_indexInParent(long __RPC_FAR *accParentIndex) override
Definition: MAccessible.cxx:2843
CMAccessible::put_accValue
STDMETHOD() put_accValue(VARIANT varChild, BSTR szValue) override
Set the accessible value of the current COM object self or its one child from UNO.
Definition: MAccessible.cxx:1052
CMAccessible::m_xContext
css::uno::Reference< css::accessibility::XAccessibleContext > m_xContext
Definition: MAccessible.h:183
CMAccessible::get_localizedExtendedRole
STDMETHOD() get_localizedExtendedRole(BSTR __RPC_FAR *localizedExtendedRole) override
Definition: MAccessible.cxx:2826
CMAccessible::get_attributes
STDMETHOD() get_attributes(BSTR *pAttr) override
Definition: MAccessible.cxx:2932
CMAccessible::m_iRole
unsigned short m_iRole
Definition: MAccessible.h:159
CMAccessible::ConvertAnyToVariant
static void ConvertAnyToVariant(const css::uno::Any &rAnyVal, VARIANT *pvData)
Definition: MAccessible.cxx:2664
CMAccessible::get_uniqueID
STDMETHOD() get_uniqueID(long __RPC_FAR *uniqueID) override
Definition: MAccessible.cxx:1999
CMAccessible::get_accSelection
STDMETHOD() get_accSelection(VARIANT *pvarChildren) override
Returns the selection of the current COM object to AT.
Definition: MAccessible.cxx:826
CMAccessible::get_extendedStates
STDMETHOD() get_extendedStates(long maxExtendedStates, BSTR __RPC_FAR *__RPC_FAR *extendedStates, long __RPC_FAR *nExtendedStates) override
Definition: MAccessible.cxx:1993
CMAccessible::accLocation
STDMETHOD() accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild) override
Returns the location of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:878
CMAccessible::get_String4Numbering
static OUString get_String4Numbering(const css::uno::Any &pAny, sal_Int16 numberingLevel, std::u16string_view numberingPrefix)
Definition: MAccessible.cxx:2621
CMAccessible::accNavigate
STDMETHOD() accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt) override
Returns the current focused child to AT.
Definition: MAccessible.cxx:926
CMAccessible::get_accParent
STDMETHOD() get_accParent(IDispatch **ppdispParent) override
Returns the Parent IAccessible interface pointer to AT.
Definition: MAccessible.cxx:234
CMAccessible::GetChildInterface
IMAccessible * GetChildInterface(long dChildIndex)
private methods that help implement public functions
Definition: MAccessible.cxx:1302
CMAccessible::get_windowHandle
STDMETHOD() get_windowHandle(HWND __RPC_FAR *windowHandle) override
Definition: MAccessible.cxx:2016
CMAccessible::accDoDefaultAction
STDMETHOD() accDoDefaultAction(VARIANT varChild) override
AT call this method to operate application.
Definition: MAccessible.cxx:2259
CMAccessible::get_nActions
STDMETHOD() get_nActions(long __RPC_FAR *nActions)
Definition: MAccessible.cxx:1748
CMAccessible::SetXAccessible
STDMETHOD() SetXAccessible(hyper) override
When COM is created, UNO set XAccessible pointer to it in order to COM can operate UNO information.
Definition: MAccessible.cxx:2070
CMAccessible::Put_XAccValue
STDMETHOD() Put_XAccValue(const OLECHAR __RPC_FAR *pszAccValue) override
Set the accessible value of the current COM object self from UNO.
Definition: MAccessible.cxx:1162
CMAccessible::scrollTo
STDMETHOD() scrollTo(enum IA2ScrollType scrollType) override
Definition: MAccessible.cxx:1784
CMAccessible::Put_ActionDescription
STDMETHOD() Put_ActionDescription(const OLECHAR *szAction) override
UNO set description information for action to COM.
Definition: MAccessible.cxx:2294
CMAccessible::get_toolkitName
STDMETHOD() get_toolkitName(BSTR __RPC_FAR *name) override
Definition: MAccessible.cxx:2914
CMAccessible::Put_XAccParent
STDMETHOD() Put_XAccParent(IMAccessible __RPC_FAR *pIParent) override
Set accessible parent object for the current COM object if the current object is a child of some COM ...
Definition: MAccessible.cxx:1240
CMAccessible::GetUNOInterface
STDMETHOD() GetUNOInterface(hyper *) override
Return XAccessible interface pointer when needed.
Definition: MAccessible.cxx:2189
CMAccessible::get_accChildCount
STDMETHOD() get_accChildCount(long *pcountChildren) override
Returns child count of current COM object.
Definition: MAccessible.cxx:271
CMAccessible::get_accState
STDMETHOD() get_accState(VARIANT varChild, VARIANT *pvarState) override
Returns the accessible state of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:529
CMAccessible::get_accValue
STDMETHOD() get_accValue(VARIANT varChild, BSTR *pszValue) override
Returns the accessible value of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:390
CMAccessible::SmartQI
HRESULT WINAPI SmartQI(void *pv, REFIID iid, void **ppvObject)
Definition: MAccessible.cxx:2388
CMAccessible::get_accChild
STDMETHOD() get_accChild(VARIANT varChild, IDispatch **ppdispChild) override
Returns child interface pointer for AT according to input child ID.
Definition: MAccessible.cxx:313
CMAccessible::get_accRole
STDMETHOD() get_accRole(VARIANT varChild, VARIANT *pvarRole) override
Returns the accessible role of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:482
CMAccessible::NotifyDestroy
STDMETHOD() NotifyDestroy() override
When a UNO control disposing, it disposes its listeners, then notify AccObject in bridge management,...
Definition: MAccessible.cxx:1284
CMAccessible::get_accHelpTopic
STDMETHOD() get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild, long *pidTopic) override
Returns the accessible HelpTopic of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:603
CMAccessible::Put_XAccFocus
STDMETHOD() Put_XAccFocus(long dChildID) override
Set accessible focus by specifying child ID.
Definition: MAccessible.cxx:1205
CMAccessible::m_containedObjects
XGUIDToComObjHash m_containedObjects
Definition: MAccessible.h:211
CMAccessible::get_toolkitVersion
STDMETHOD() get_toolkitVersion(BSTR __RPC_FAR *version) override
Definition: MAccessible.cxx:2926
CMAccessible::GetNavigateChildForDM
IMAccessible * GetNavigateChildForDM(VARIANT varCur, short flags)
for descendantmanager circumstance,provide child interface when navigate
Definition: MAccessible.cxx:1353
CMAccessible::Put_XAccName
STDMETHOD() Put_XAccName(const OLECHAR __RPC_FAR *pszName) override
Set the accessible name of the current COM object self from UNO.
Definition: MAccessible.cxx:1084
CMAccessible::m_dFocusChildID
long m_dFocusChildID
Definition: MAccessible.h:167
CMAccessible::~CMAccessible
virtual ~CMAccessible()
Definition: MAccessible.cxx:199
CMAccessible::QueryService
STDMETHOD() QueryService(REFGUID guidService, REFIID riid, void **ppvObject) override
Get The other Interface from CMAccessible.
Definition: MAccessible.cxx:1029
CMAccessible::SetDefaultAction
STDMETHOD() SetDefaultAction(hyper pAction) override
Helper method for Implementation of get_accDefaultAction.
Definition: MAccessible.cxx:2205
CMAccessible::m_pszActionDescription
BSTR m_pszActionDescription
Definition: MAccessible.h:158
CMAccessible::put_accName
STDMETHOD() put_accName(VARIANT varChild, BSTR szName) override
No longer supported according to IAccessible doc.
Definition: MAccessible.cxx:1040
CMAccessible::get_extendedRole
STDMETHOD() get_extendedRole(BSTR __RPC_FAR *extendedRole) override
Definition: MAccessible.cxx:2821
CMAccessible::get_accDefaultAction
STDMETHOD() get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction) override
This method is called when AT open some UI elements initially the UI element takes the default action...
Definition: MAccessible.cxx:2220
CMAccessible::accSelect
STDMETHOD() accSelect(long flagsSelect, VARIANT varChild) override
accSelect method has many optional flags, needs to process comprehensively Mozilla and Microsoft do n...
Definition: MAccessible.cxx:2092
CMAccessible::GetNextSibling
HRESULT GetNextSibling(VARIANT varStart, VARIANT *pvarEndUpAt)
The method GetNextSibling is general, whatever it is descendant manage or not Get the next sibling ob...
Definition: MAccessible.cxx:1508
CMAccessible::GetXInterfaceFromXAccessible
static bool GetXInterfaceFromXAccessible(css::accessibility::XAccessible *, css::uno::XInterface **, XInterfaceType)
Definition: MAccessible.cxx:2312
CMAccessible::accHitTest
STDMETHOD() accHitTest(long xLeft, long yTop, VARIANT *pvarChild) override
Definition: MAccessible.cxx:968
CMAccessible::Put_XAccAgent
STDMETHOD() Put_XAccAgent(hyper pAgent) override
Set AccObjectManagerAgent object pointer to COM.
Definition: MAccessible.cxx:1270
CMAccessible::GetFirstChild
HRESULT GetFirstChild(VARIANT varStart, VARIANT *pvarEndUpAt)
the following 4 private methods are for accNavigate implementation
Definition: MAccessible.cxx:1435
CMAccessible::get_accDescription
STDMETHOD() get_accDescription(VARIANT varChild, BSTR *pszDescription) override
Returns the accessible description of the current COM object self or its one child to AT.
Definition: MAccessible.cxx:435
CMAccessible::get_groupPosition
STDMETHOD() get_groupPosition(long __RPC_FAR *groupLevel, long __RPC_FAR *similarItemsInGroup, long __RPC_FAR *positionInGroup) override
Definition: MAccessible.cxx:1811
CMAccessible::get_relations
STDMETHOD() get_relations(long maxRelations, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation, long __RPC_FAR *nRelations) override
Definition: MAccessible.cxx:1673
CMAccessible::GetContextByXAcc
static css::accessibility::XAccessibleContext * GetContextByXAcc(css::accessibility::XAccessible *pXAcc)
Get XAccessibleContext directly from UNO by the stored XAccessible pointer.
Definition: MAccessible.cxx:2052
CMAccessible::Put_XAccRole
STDMETHOD() Put_XAccRole(unsigned short pRole) override
Set the accessible role of the current COM object self from UNO.
Definition: MAccessible.cxx:1110
CMAccessible::IncreaseState
STDMETHOD() IncreaseState(DWORD pXSate) override
Delete one state into the current state set for the current COM object from UNO.
Definition: MAccessible.cxx:1136
utl::ConfigManager::getProductVersion
static OUString getProductVersion()
utl::ConfigManager::getProductName
static OUString getProductName()
nCount
int nCount
UACC_NO_FOCUS
const long UACC_NO_FOCUS
Definition: defines.idl:26
y
float y
x
float x
eType
DocumentType eType
name
const char * name
IA2ScrollType
IA2ScrollType
These constants control the scrolling of an object or substring into a window.
Definition: ia2_api_all.idl:114
IA2CoordinateType
IA2CoordinateType
These constants define which coordinate system a point is located in.
Definition: ia2_api_all.idl:197
IA2_STATE_STALE
@ IA2_STATE_STALE
Indicates that the accessible object is stale.
Definition: ia2_api_all.idl:1149
IA2_STATE_EDITABLE
@ IA2_STATE_EDITABLE
An object with this state has a caret and implements the IAccessibleText interface.
Definition: ia2_api_all.idl:1090
IA2_STATE_DEFUNCT
@ IA2_STATE_DEFUNCT
Indicates the user interface object corresponding to this object no longer exists.
Definition: ia2_api_all.idl:1082
IA2_STATE_ICONIFIED
@ IA2_STATE_ICONIFIED
Indicates this object is minimized and is represented only by an icon.
Definition: ia2_api_all.idl:1096
IA2_STATE_MULTI_LINE
@ IA2_STATE_MULTI_LINE
Indicates this text object can contain multiple lines of text.
Definition: ia2_api_all.idl:1121
IA2_STATE_OPAQUE
@ IA2_STATE_OPAQUE
Indicates this object paints every pixel within its rectangular region.
Definition: ia2_api_all.idl:1124
IA2_STATE_MODAL
@ IA2_STATE_MODAL
Indicates that an object is modal.
Definition: ia2_api_all.idl:1118
IA2_STATE_INVALID_ENTRY
@ IA2_STATE_INVALID_ENTRY
Indicates an input validation failure.
Definition: ia2_api_all.idl:1099
IA2_STATE_HORIZONTAL
@ IA2_STATE_HORIZONTAL
Indicates the orientation of this object is horizontal.
Definition: ia2_api_all.idl:1093
IA2_STATE_REQUIRED
@ IA2_STATE_REQUIRED
Indicates that user interaction is required.
Definition: ia2_api_all.idl:1131
IA2_STATE_ARMED
@ IA2_STATE_ARMED
Indicates that the object is armed.
Definition: ia2_api_all.idl:1079
IA2_STATE_SUPPORTS_AUTOCOMPLETION
@ IA2_STATE_SUPPORTS_AUTOCOMPLETION
Indicates that the object implements autocompletion.
Definition: ia2_api_all.idl:1157
IA2_STATE_VERTICAL
@ IA2_STATE_VERTICAL
Indicates the orientation of this object is vertical.
Definition: ia2_api_all.idl:1175
IA2_STATE_ACTIVE
@ IA2_STATE_ACTIVE
Indicates a window is currently the active window, or is an active subelement within a container or t...
Definition: ia2_api_all.idl:1066
IA2_STATE_MANAGES_DESCENDANTS
@ IA2_STATE_MANAGES_DESCENDANTS
Indicates that this object manages its children.
Definition: ia2_api_all.idl:1111
IA2_STATE_SELECTABLE_TEXT
@ IA2_STATE_SELECTABLE_TEXT
Indicates an object which supports text selection.
Definition: ia2_api_all.idl:1137
IA2_STATE_SINGLE_LINE
@ IA2_STATE_SINGLE_LINE
Indicates that this text object can contain only a single line of text.
Definition: ia2_api_all.idl:1140
IA2_STATE_TRANSIENT
@ IA2_STATE_TRANSIENT
Indicates this object is transient.
Definition: ia2_api_all.idl:1172
IA2_ROLE_CAPTION
@ IA2_ROLE_CAPTION
A caption describing another object.
Definition: ia2_api_all.idl:771
IAccessibleAction
This interface gives access to actions that can be executed for accessible objects.
Definition: ia2_api_all.idl:576
IAccessibleAction::nActions
HRESULT nActions([out, retval] long *nActions)
Returns the number of accessible actions available in this object.
IAccessibleRelation
This interface gives access to an object's set of relations.
Definition: ia2_api_all.idl:410
IMAccessible::GetUNOInterface
HRESULT GetUNOInterface(hyper *UNOInterface)
IMAccessible::Put_XAccFocus
HRESULT Put_XAccFocus(long dChildID)
IUNOXWrapper::put_XSubInterface
HRESULT put_XSubInterface(hyper pXSubInterface)
IUNOXWrapper::put_XInterface
HRESULT put_XInterface(hyper pXInterface)
nIndex
sal_Int32 nIndex
SAL_WARN
#define SAL_WARN(area, stream)
SAL_N_ELEMENTS
#define SAL_N_ELEMENTS(arr)
aStr
aStr
comphelper::GetkeyBindingStrByXkeyBinding
OUString GetkeyBindingStrByXkeyBinding(const Sequence< KeyStroke > &keySet)
i
int i
index
index
h
sal_Int32 h
w
sal_Int32 w
VT_EMPTY
#define VT_EMPTY
VT_R4
#define VT_R4
VT_BSTR
#define VT_BSTR
VT_R8
#define VT_R8
VT_BOOL
#define VT_BOOL
VT_I4
#define VT_I4
VT_UI1
#define VT_UI1
VT_I2
#define VT_I2
VERTICAL
const int VERTICAL
hr
return hr
IA2Locale
A structure defining the locale of an accessible object.
Definition: ia2_api_all.idl:1561
OPAQUE
#define OPAQUE
sal_Unicode
sal_uInt16 sal_Unicode
sal_Int8
signed char sal_Int8
Generated on Sun Jul 30 2023 04:35:17 for LibreOffice Module winaccessibility (master) by doxygen 1.9.3