winaccessibility/source/UAccCOM/AccRelation.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 "stdafx.h"
  21 #include "AccRelation.h"
  22
  23 #if defined __clang__
  24 #pragma clang diagnostic push
  25 #pragma clang diagnostic ignored "-Wnon-virtual-dtor"
  26 #endif
  27 #include  <UAccCOM.h>
  28 #if defined __clang__
  29 #pragma clang diagnostic pop
  30 #endif
  31
  32 #include <vcl/svapp.hxx>
  33
  34 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  35 #include <com/sun/star/accessibility/XAccessible.hpp>
  36 #include <com/sun/star/accessibility/XAccessibleContext.hpp>
  37 #include "MAccessible.h"
  38
  39 using namespace com::sun::star::accessibility;
  40 using namespace com::sun::star::uno;
  41
  42 /**
  43    * Get relation type.
  44    * @param relationType Variant to get relation type.
  45    * @return Result.
  46 */
  47 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccRelation::get_relationType(BSTR * relationType)
  48 {
  49     SolarMutexGuard g;
  50
  51     ENTER_PROTECTED_BLOCK
  52
  53     if (relationType == nullptr)
  54         return E_INVALIDARG;
  55
  56     int type = relation.RelationType;
  57     SAFE_SYSFREESTRING(*relationType);
  58
  59     *relationType = getRelationTypeBSTR(type);
  60     return S_OK;
  61
  62     LEAVE_PROTECTED_BLOCK
  63 }
  64
  65 // Gets what the type of localized relation is.
  66 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccRelation::get_localizedRelationType(BSTR *)
  67 {
  68
  69
  70     ENTER_PROTECTED_BLOCK
  71
  72     return S_OK;
  73
  74     LEAVE_PROTECTED_BLOCK
  75 }
  76
  77 /**
  78    * Get targets length.
  79    * @param nTargets Variant to get targets length.
  80    * @return Result.
  81 */
  82 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccRelation::get_nTargets(long * nTargets)
  83 {
  84     SolarMutexGuard g;
  85
  86     ENTER_PROTECTED_BLOCK
  87
  88     if (nTargets == nullptr)
  89         return E_INVALIDARG;
  90
  91     Sequence< Reference< XInterface > > xTargets = relation.TargetSet;
  92     *nTargets = xTargets.getLength();
  93     return S_OK;
  94
  95     LEAVE_PROTECTED_BLOCK
  96 }
  97
  98 /**
  99    * Get special target.
 100    * @param targetIndex target index.
 101    * @param target      Variant to get special target.
 102    * @return Result.
 103 */
 104 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccRelation::get_target(long targetIndex, IUnknown * * target)
 105 {
 106     SolarMutexGuard g;
 107
 108     ENTER_PROTECTED_BLOCK
 109
 110     if (target == nullptr)
 111         return E_FAIL;
 112
 113     Sequence< Reference< XInterface > > xTargets = relation.TargetSet;
 114     int nCount = xTargets.getLength();
 115     if( targetIndex >= nCount )
 116         return E_FAIL;
 117
 118     Reference<XAccessible> xRAcc(xTargets[targetIndex], UNO_QUERY);
 119     IAccessible* pRet = nullptr;
 120
 121     bool isGet = CMAccessible::get_IAccessibleFromXAccessible(xRAcc.get(), &pRet);
 122     if(isGet)
 123     {
 124         *target = /*(IAccessible2 *)*/static_cast<IUnknown*>(pRet);
 125         pRet->AddRef();
 126         return S_OK;
 127     }
 128
 129     return E_FAIL;
 130
 131     LEAVE_PROTECTED_BLOCK
 132 }
 133
 134 /**
 135    * Get special targets.
 136    * @param maxTargets Special targets count.
 137    * @param target Variant to get special target.
 138    * @param nTargets Variant to accept actual target length.
 139    * @return Result.
 140 */
 141 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccRelation::get_targets(long, IUnknown * * target, long * nTargets)
 142 {
 143     SolarMutexGuard g;
 144
 145     ENTER_PROTECTED_BLOCK
 146
 147     // #CHECK#
 148     if(target == nullptr)
 149         return E_INVALIDARG;
 150     if (nTargets == nullptr)
 151         return E_INVALIDARG;
 152
 153     Sequence< Reference< XInterface > > xTargets = relation.TargetSet;
 154     int nCount = xTargets.getLength();
 155
 156     *target = static_cast<IUnknown*>(::CoTaskMemAlloc(nCount*sizeof(IUnknown)));
 157
 158     // #CHECK Memory Allocation#
 159     if(*target == nullptr)
 160     {
 161         return E_FAIL;
 162     }
 163
 164     for(int i=0; i<nCount ; i++)
 165     {
 166         IUnknown* pAcc = nullptr;
 167         HRESULT hr = get_target(i,&pAcc);
 168         if(SUCCEEDED(hr))
 169             target[i] = pAcc;
 170     }
 171
 172     *nTargets = nCount;
 173     return S_OK;
 174
 175     LEAVE_PROTECTED_BLOCK
 176 }
 177
 178 /**
 179    * Put UNO interface.
 180    * @param pXSubInterface AccessibleRelation pointer.
 181    * @return Result.
 182 */
 183 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccRelation::put_XSubInterface(hyper pXSubInterface)
 184 {
 185     // internal IUNOXWrapper - no mutex meeded
 186
 187     relation = *reinterpret_cast<AccessibleRelation*>(pXSubInterface);
 188     return S_OK;
 189 }
 190
 191 /**
 192    * Get relation type string by type.
 193    * @param type Relation type.
 194    * @return relation type string.
 195 */
 196 BSTR CAccRelation::getRelationTypeBSTR(int type)
 197 {
 198     static LPCWSTR map[] =
 199         {
 200             L"INVALID",                  // AccessibleRelationType::INVALID
 201             IA2_RELATION_FLOWS_FROM,     // AccessibleRelationType::CONTENT_FLOWS_FROM
 202             IA2_RELATION_FLOWS_TO,       // AccessibleRelationType::CONTENT_FLOWS_TO
 203             IA2_RELATION_CONTROLLED_BY,  // AccessibleRelationType::CONTROLLED_BY
 204             IA2_RELATION_CONTROLLER_FOR, // AccessibleRelationType::CONTROLLER_FOR
 205             IA2_RELATION_LABEL_FOR,      // AccessibleRelationType::LABEL_FOR
 206             IA2_RELATION_LABELED_BY,     // AccessibleRelationType::LABELED_BY
 207             IA2_RELATION_MEMBER_OF,      // AccessibleRelationType::MEMBER_OF
 208             IA2_RELATION_SUBWINDOW_OF,   // AccessibleRelationType::SUB_WINDOW_OF
 209             IA2_RELATION_NODE_CHILD_OF,  // AccessibleRelationType::NODE_CHILD_OF
 210             IA2_RELATION_DESCRIBED_BY    // AccessibleRelationType::DESCRIBED_BY
 211         };
 212
 213     return ::SysAllocString( (type >= AccessibleRelationType::INVALID && type <= AccessibleRelationType::DESCRIBED_BY)
 214                              ? map[type] : L"");
 215 }
 216
 217 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */