winaccessibility/source/UAccCOM/MAccessible.cxx

   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
  65 using namespace com::sun::star::uno;
  66 using namespace com::sun::star::accessibility;
  67 using namespace com::sun::star::accessibility::AccessibleStateType;
  68
  69 namespace {
  70
  71 enum 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
  88 template <class Interface>
  89 bool 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.
 110 bool 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
 134 long 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
 156 sal_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
 178 using namespace com::sun::star::accessibility::AccessibleRole;
 179
 180
 181 AccObjectManagerAgent* CMAccessible::g_pAgent = nullptr;
 182
 183 CMAccessible::CMAccessible():
 184 m_pszName(nullptr),
 185 m_pszValue(nullptr),
 186 m_pszActionDescription(nullptr),
 187 m_iRole(0x00),
 188 m_dState(0x00),
 189 m_pIParent(nullptr),
 190 m_dChildID(0x00),
 191 m_dFocusChildID(UACC_NO_FOCUS),
 192 m_hwnd(nullptr),
 193 m_isDestroy(false)
 194 {
 195     CEnumVariant::Create(&m_pEnumVar);
 196     m_containedObjects.clear();
 197 }
 198
 199 CMAccessible::~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
 226 /**
 227 * Returns the Parent IAccessible interface pointer to AT.
 228 * It should add reference, and the client should release the component.
 229 * It should return E_FAIL when the parent point is null.
 230 * @param    ppdispParent [in,out] used to return the parent interface point.
 231 *           when the point is null, should return null.
 232 * @return   S_OK if successful and E_FAIL if the m_pIParent is NULL.
 233 */
 234 COM_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
 266 /**
 267 * Returns child count of current COM object.
 268 * @param    pcountChildren [in,out] used to return the children count.
 269 * @return   S_OK if successful.
 270 */
 271 COM_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
 306 /**
 307 * Returns child interface pointer for AT according to input child ID.
 308 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 309 * the child ID specify child index from 0 to children count, 0 stands for object self.
 310 * @param    ppdispChild, [in,out] use to return the child interface point.
 311 * @return   S_OK if successful and S_FALSE if failure.
 312 */
 313 COM_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
 344 /**
 345 * Returns the accessible name of the current COM object self or its one child to AT.
 346 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 347 * the child ID specify child index from 0 to children count, 0 stands for object self.
 348 * @param    pszName, [in,out] use to return the name of the proper object.
 349 * @return   S_OK if successful and S_FALSE if failure.
 350 */
 351 COM_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
 383 /**
 384 * Returns the accessible value of the current COM object self or its one child to AT.
 385 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 386 * the child ID specify child index from 0 to children count, 0 stands for object self.
 387 * @param    pszValue, [in,out] use to return the value of the proper object.
 388 * @return   S_OK if successful and S_FALSE if failure.
 389 */
 390 COM_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
 428 /**
 429 * Returns the accessible description of the current COM object self or its one child to AT.
 430 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 431 * the child ID specify child index from 0 to children count, 0 stands for object self.
 432 * @param    pszDescription, [in,out] use to return the description of the proper object.
 433 * @return   S_OK if successful and E_FAIL if failure.
 434 */
 435 COM_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
 475 /**
 476 * Returns the accessible role of the current COM object self or its one child to AT.
 477 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 478 * the child ID specify child index from 0 to children count, 0 stands for object self.
 479 * @param    pvarRole, [in,out] use to return the role of the proper object.
 480 * @return   S_OK if successful and S_FALSE if failure.
 481 */
 482 COM_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
 522 /**
 523 * Returns the accessible state of the current COM object self or its one child to AT.
 524 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 525 * the child ID specify child index from 0 to children count, 0 stands for object self.
 526 * @param    pvarState, [in,out] use to return the state of the proper object.
 527 * @return   S_OK if successful and S_FALSE if failure.
 528 */
 529 COM_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
 582 /**
 583 * Returns the accessible helpString of the current COM object self or its one child to AT.
 584 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 585 * the child ID specify child index from 0 to children count, 0 stands for object self.
 586 * @param    pszHelp, [in,out] use to return the helpString of the proper object.
 587 * @return   S_OK if successful and E_FAIL if failure.
 588 */
 589 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accHelp(VARIANT, BSTR *)
 590 {
 591     return E_NOTIMPL;
 592 }
 593
 594 /**
 595 * Returns the accessible HelpTopic of the current COM object self or its one child to AT.
 596 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 597 * the child ID specify child index from 0 to children count, 0 stands for object self.
 598 * @param    pszHelpFile, [in,out] use to return the HelpTopic of the proper object.
 599 * @param    pidTopic, use to return the HelpTopic ID of the proper object.
 600 * @return   S_OK if successful and E_FAIL if failure.
 601 * Not implemented yet
 602 */
 603 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_accHelpTopic(BSTR *, VARIANT, long *)
 604 {
 605     return E_NOTIMPL;
 606 }
 607
 608 static 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
 623 /**
 624 * Returns the accessible keyboard shortcut of the current COM object self or its one child to AT.
 625 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 626 * the child ID specify child index from 0 to children count, 0 stands for object self.
 627 * @param    pszKeyboardShortcut, [in,out] use to return the kbshortcut of the proper object.
 628 * @return   S_OK if successful and E_FAIL if failure.
 629 */
 630 COM_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
 777 /**
 778 * Returns the current focused child to AT.
 779 * @param    pvarChild, [in,out] vt member of pvarChild must be VT_I4,and lVal member stores the child ID,
 780 * the child ID specify child index from 0 to children count, 0 stands for object self.
 781 * @return   S_OK if successful and E_FAIL if failure.
 782 */
 783 COM_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
 818 /**
 819 * Returns the selection of the current COM object to AT.
 820 * @param    pvarChildren,[in,out]
 821 * if selection num is 0,return VT_EMPTY for vt,
 822 * if selection num is 1,return VT_I4 for vt,and child index for lVal
 823 * if selection num >1,return VT_UNKNOWN for vt, and IEnumVariant* for punkVal
 824 * @return   S_OK if successful and S_FALSE if failure.
 825 */
 826 COM_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
 868 /**
 869 * Returns the location of the current COM object self or its one child to AT.
 870 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
 871 * the child ID specify child index from 0 to children count, 0 stands for object self.
 872 * @param    pxLeft, [in,out] use to return the x-coordination of the proper object.
 873 * @param    pyTop,  [in,out] use to return the y-coordination of the proper object.
 874 * @param    pcxWidth, [in,out] use to return the x-coordination width of the proper object.
 875 * @param    pcyHeight, [in,out] use to return the y-coordination height of the proper object.
 876 * @return   S_OK if successful and S_FALSE if failure.
 877 */
 878 COM_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
 919 /**
 920 * Returns the current focused child to AT.
 921 * @param    navDir, the direction flag of the navigation.
 922 * @param    varStart, the start child id of this navigation action.
 923 * @param    pvarEndUpAt, [in,out] the end up child of this navigation action.
 924 * @return   S_OK if successful and E_FAIL if failure.
 925 */
 926 COM_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
 968 COM_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
1023 /**
1024 * Get The other Interface from CMAccessible.
1025 * @param    guidService, must be IID_IAccessible here.
1026 * @param    riid, the IID interface .
1027 * @return   S_OK if successful and S_FALSE if failure.
1028 */
1029 COM_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
1036 /**
1037 * No longer supported according to IAccessible doc.
1038 * Servers should return E_NOTIMPL
1039 */
1040 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::put_accName(VARIANT, BSTR)
1041 {
1042     return E_NOTIMPL;
1043 }
1044
1045 /**
1046 * Set the accessible value of the current COM object self or its one child from UNO.
1047 * @param    varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
1048 * the child ID specify child index from 0 to children count, 0 stands for object self.
1049 * @param    szValue, the value used to set the value of the proper object.
1050 * @return   S_OK if successful and E_FAIL if failure.
1051 */
1052 COM_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
1079 /**
1080 * Set the accessible name of the current COM object self from UNO.
1081 * @param    pszName, the name value used to set the name of the current object.
1082 * @return   S_OK if successful and E_FAIL if failure.
1083 */
1084 COM_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
1105 /**
1106 * Set the accessible role of the current COM object self from UNO.
1107 * @param    pRole, the role value used to set the role of the current object.
1108 * @return   S_OK if successful and E_FAIL if failure.
1109 */
1110 COM_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
1118 /**
1119 * Add one state into the current state set for the current COM object from UNO.
1120 * @param    pXSate, the state used to set the name of the current object.
1121 * @return   S_OK if successful and E_FAIL if failure.
1122 */
1123 COM_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
1131 /**
1132 * Delete one state into the current state set for the current COM object from UNO.
1133 * @param    pXSate, the state used to set the name of the current object.
1134 * @return   S_OK if successful and E_FAIL if failure.
1135 */
1136 COM_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
1144 /**
1145 * Set state into the current state set for the current COM object from UNO.
1146 * @param    pXSate, the state used to set the name of the current object.
1147 * @return   S_OK if successful and E_FAIL if failure.
1148 */
1149 COM_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
1157 /**
1158 * Set the accessible value of the current COM object self from UNO.
1159 * @param    pszAccValue, the name used to set the value of the current object.
1160 * @return   S_OK if successful and E_FAIL if failure.
1161 */
1162 COM_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
1182 /**
1183 * Set the HWND value of the current COM object self from UNO. It should set the parent IAccessible
1184 * Object through the method AccessibleObjectFromWindow(...).
1185 * @param    hwnd, the HWND used to set the value of the current object.
1186 * @return   S_OK if successful and E_FAIL if failure.
1187 */
1188 COM_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
1200 /**
1201 * Set accessible focus by specifying child ID
1202 * @param    dChildID, the child id identifies the focus child.
1203 * @return   S_OK if successful and E_FAIL if failure.
1204 */
1205 COM_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
1234 /**
1235 * Set accessible parent object for the current COM object if
1236 * the current object is a child of some COM object
1237 * @param    pIParent, the parent of the current object.
1238 * @return   S_OK if successful and E_FAIL if failure.
1239 */
1240 COM_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
1252 /**
1253 * Set unique child id to COM
1254 * @param    dChildID, the id of the current object.
1255 * @return   S_OK if successful and E_FAIL if failure.
1256 */
1257 COM_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
1265 /**
1266 * Set AccObjectManagerAgent object pointer to COM
1267 * @param    pAgent, the AccObjectManagerAgent point.
1268 * @return   S_OK if successful and E_FAIL if failure.
1269 */
1270 COM_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
1278 /**
1279 * When a UNO control disposing, it disposes its listeners,
1280 * then notify AccObject in bridge management, then notify
1281 * COM that the XAccessible is invalid, so set m_xAccessible as NULL
1282 * @return   S_OK if successful and E_FAIL if failure.
1283 */
1284 COM_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
1293 /**
1294 *private methods that help implement public functions
1295 */
1296
1297 /**
1298 * Return child interface pointer by child ID,note: need to call AddRef()
1299 * @param    lChildID, specify child index,which AT(such as Inspect32) gives.
1300 * @return  IMAccessible*, pointer to the corresponding child object.
1301 */
1302 IMAccessible* 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
1347 /**
1348 * for descendantmanager circumstance,provide child interface when navigate
1349 * @param    varCur, the current child.
1350 * @param    flags, the navigation direction.
1351 * @return  IMAccessible*, the child of the end up node.
1352 */
1353 IMAccessible* 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
1424 /**
1425 *the following 4 private methods are for accNavigate implementation
1426 */
1427
1428 /**
1429 * Return first child for parent container, process differently according
1430 * to whether it is descendant manage
1431 * @param    varStart, the start child id of this navigation action.
1432 * @param    pvarEndUpAt, [in,out] the end up child of this navigation action.
1433 * @return   S_OK if successful and E_FAIL if failure.
1434 */
1435 HRESULT 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
1465 /**
1466 * Return last child for parent container, process differently according
1467 * to whether it is descendant manage
1468 * @param    varStart, the start child id of this navigation action.
1469 * @param    pvarEndUpAt, [in,out] the end up child of this navigation action.
1470 * @return   S_OK if successful and E_FAIL if failure.
1471 */
1472 HRESULT 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
1501 /**
1502 * The method GetNextSibling is general, whatever it is descendant manage or not
1503 * Get the next sibling object.
1504 * @param    varStart, the start child id of this navigation action.
1505 * @param    pvarEndUpAt, [in,out] the end up child of this navigation action.
1506 * @return   S_OK if successful and E_FAIL if failure.
1507 */
1508 HRESULT 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
1537 /**
1538 *the method GetPreSibling is general, whatever it is descendant manage or not
1539 * @param    varStart, the start child id of this navigation action.
1540 * @param    pvarEndUpAt, [in,out] the end up child of this navigation action.
1541 * @return   S_OK if successful and E_FAIL if failure.
1542 */
1543 HRESULT 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
1577 /**
1578 * For IAccessible2 implementation methods
1579 */
1580 COM_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
1611 COM_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
1673 COM_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
1734 COM_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
1748 COM_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
1779 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::scrollToPoint(enum IA2CoordinateType, long, long)
1780 {
1781     return E_NOTIMPL;
1782 }
1783
1784 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::scrollTo(enum IA2ScrollType)
1785 {
1786     return E_NOTIMPL;
1787 }
1788
1789 static 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
1811 COM_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
1993 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_extendedStates(long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *)
1994 {
1995     return E_NOTIMPL;
1996 }
1997
1998
1999 COM_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
2016 COM_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
2047 /**
2048 * Get XAccessibleContext directly from UNO by the stored XAccessible pointer
2049 * @param    pXAcc, UNO XAccessible object point.
2050 * @return   XAccessibleContext*, the context of the pXAcc.
2051 */
2052 XAccessibleContext* 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
2064 /**
2065 * When COM is created, UNO set XAccessible pointer to it
2066 * in order to COM can operate UNO information
2067 * @param    pXAcc, the XAccessible object of current object.
2068 * @return  S_OK if successful.
2069 */
2070 COM_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
2083 /**
2084 * accSelect method has many optional flags, needs to process comprehensively
2085 * Mozilla and Microsoft do not implement SELFLAG_EXTENDSELECTION flag.
2086 * The implementation of this flag is a little trouble-shooting,so we also
2087 * do not implement it now
2088 * @param    flagsSelect, the selection flag of the select action.
2089 * @param    varChild, the child object pointer of current action.
2090 * @return  S_OK if successful.
2091 */
2092 COM_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
2184 /**
2185 * Return XAccessible interface pointer when needed
2186 * @param pXAcc, [in, out] the Uno interface of the current object.
2187 * @return S_OK if successful.
2188 */
2189 COM_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
2200 /**
2201 * Helper method for Implementation of get_accDefaultAction
2202 * @param pAction, the default action point of the current object.
2203 * @return S_OK if successful.
2204 */
2205 COM_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
2213 /**
2214 * This method is called when AT open some UI elements initially
2215 * the UI element takes the default action defined here
2216 * @param varChild, the child id of the defaultaction.
2217 * @param pszDefaultAction,[in/out] the description of the current action.
2218 * @return S_OK if successful.
2219 */
2220 COM_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
2254 /**
2255 * AT call this method to operate application
2256 * @param varChild, the child id of the action object.
2257 * @return S_OK if successful.
2258 */
2259 COM_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
2289 /**
2290 * UNO set description information for action to COM.
2291 * @param szAction, the action description of the current object.
2292 * @return S_OK if successful.
2293 */
2294 COM_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
2312 bool 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
2348 template<typename T> static HRESULT
2349 createAggInstance(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
2360 typedef HRESULT (AggCreatorFunc)(CMAccessible &, void **);
2361
2362 namespace {
2363
2364 struct AggMapEntry
2365 {
2366     const IID* piid;
2367     AggCreatorFunc* pfnCreateInstance;
2368     const XInterfaceType eXInterfaceType;
2369 };
2370
2371 }
2372
2373 static 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
2388 HRESULT 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
2447 bool 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
2468 OUString 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
2621 OUString 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
2664 void 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
2793 COM_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
2821 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_extendedRole(BSTR __RPC_FAR *)
2822 {
2823     return E_NOTIMPL;
2824 }
2825
2826 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_localizedExtendedRole(BSTR __RPC_FAR *)
2827 {
2828     return E_NOTIMPL;
2829 }
2830
2831 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_nExtendedStates(long __RPC_FAR *)
2832 {
2833     return E_NOTIMPL;
2834 }
2835
2836
2837 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_localizedExtendedStates(long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *)
2838 {
2839     return E_NOTIMPL;
2840 }
2841
2842
2843 COM_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 }
2867 COM_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
2887 COM_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 }
2901 COM_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 }
2914 COM_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 }
2926 COM_DECLSPEC_NOTHROW STDMETHODIMP CMAccessible::get_toolkitVersion(BSTR __RPC_FAR *version)
2927 {
2928     return get_appVersion(version);
2929 }
2930
2931
2932 COM_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: */