unotools/source/accessibility/accessiblerelationsethelper.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 <unotools/accessiblerelationsethelper.hxx>
  21 #include <vector>
  22 #include <comphelper/sequence.hxx>
  23 #include <comphelper/servicehelper.hxx>
  24
  25 using namespace ::utl;
  26 using namespace ::com::sun::star;
  27 using namespace ::com::sun::star::accessibility;
  28
  29 class AccessibleRelationSetHelperImpl
  30 {
  31 public:
  32     AccessibleRelationSetHelperImpl();
  33     AccessibleRelationSetHelperImpl(const AccessibleRelationSetHelperImpl& rImpl);
  34     ~AccessibleRelationSetHelperImpl();
  35
  36     sal_Int32 getRelationCount(  )
  37         throw (uno::RuntimeException);
  38     AccessibleRelation getRelation( sal_Int32 nIndex )
  39             throw (lang::IndexOutOfBoundsException,
  40                     uno::RuntimeException);
  41     bool containsRelation( sal_Int16 aRelationType )
  42         throw (uno::RuntimeException);
  43     AccessibleRelation getRelationByType( sal_Int16 aRelationType )
  44             throw (uno::RuntimeException);
  45     void AddRelation(const AccessibleRelation& rRelation)
  46             throw (uno::RuntimeException);
  47
  48 private:
  49     std::vector<AccessibleRelation> maRelations;
  50 };
  51
  52 AccessibleRelationSetHelperImpl::AccessibleRelationSetHelperImpl()
  53 {
  54 }
  55
  56 AccessibleRelationSetHelperImpl::AccessibleRelationSetHelperImpl(const AccessibleRelationSetHelperImpl& rImpl)
  57     : maRelations(rImpl.maRelations)
  58 {
  59 }
  60
  61 AccessibleRelationSetHelperImpl::~AccessibleRelationSetHelperImpl()
  62 {
  63 }
  64
  65 sal_Int32 AccessibleRelationSetHelperImpl::getRelationCount(  )
  66     throw (uno::RuntimeException)
  67 {
  68     return maRelations.size();
  69 }
  70
  71 AccessibleRelation AccessibleRelationSetHelperImpl::getRelation( sal_Int32 nIndex )
  72     throw (lang::IndexOutOfBoundsException,
  73             uno::RuntimeException)
  74 {
  75     if ((nIndex < 0) || (static_cast<sal_uInt32>(nIndex) >= maRelations.size()))
  76         throw lang::IndexOutOfBoundsException();
  77     return maRelations[nIndex];
  78 }
  79
  80 bool AccessibleRelationSetHelperImpl::containsRelation( sal_Int16 aRelationType )
  81     throw (uno::RuntimeException)
  82 {
  83     AccessibleRelation defaultRelation; // default is INVALID
  84     AccessibleRelation relationByType = getRelationByType(aRelationType);
  85     return relationByType.RelationType != defaultRelation.RelationType;
  86 }
  87
  88 AccessibleRelation AccessibleRelationSetHelperImpl::getRelationByType( sal_Int16 aRelationType )
  89     throw (uno::RuntimeException)
  90 {
  91     sal_Int32 nCount(getRelationCount());
  92     sal_Int32 i(0);
  93     bool bFound(false);
  94     while ((i < nCount) && !bFound)
  95     {
  96         if (maRelations[i].RelationType == aRelationType)
  97             return maRelations[i];
  98         else
  99             i++;
 100     }
 101     return AccessibleRelation();
 102 }
 103
 104 void AccessibleRelationSetHelperImpl::AddRelation(const AccessibleRelation& rRelation)
 105     throw (uno::RuntimeException)
 106 {
 107     sal_Int32 nCount(getRelationCount());
 108     sal_Int32 i(0);
 109     bool bFound(false);
 110     while ((i < nCount) && !bFound)
 111     {
 112         if (maRelations[i].RelationType == rRelation.RelationType)
 113             bFound = true;
 114         else
 115             i++;
 116     }
 117     if (bFound)
 118         maRelations[i].TargetSet = comphelper::concatSequences(maRelations[i].TargetSet, rRelation.TargetSet);
 119     else
 120         maRelations.push_back(rRelation);
 121 }
 122
 123 //=====  internal  ============================================================
 124
 125 AccessibleRelationSetHelper::AccessibleRelationSetHelper ()
 126     : mpHelperImpl(NULL)
 127 {
 128     mpHelperImpl = new AccessibleRelationSetHelperImpl();
 129 }
 130
 131 AccessibleRelationSetHelper::AccessibleRelationSetHelper (const AccessibleRelationSetHelper& rHelper)
 132     : cppu::WeakImplHelper1<XAccessibleRelationSet>()
 133     , mpHelperImpl(NULL)
 134 {
 135     if (rHelper.mpHelperImpl)
 136         mpHelperImpl = new AccessibleRelationSetHelperImpl(*rHelper.mpHelperImpl);
 137     else
 138         mpHelperImpl = new AccessibleRelationSetHelperImpl();
 139 }
 140
 141 AccessibleRelationSetHelper::~AccessibleRelationSetHelper()
 142 {
 143     delete mpHelperImpl;
 144 }
 145
 146 //=====  XAccessibleRelationSet  ==============================================
 147
 148     /** Returns the number of relations in this relation set.
 149
 150         @return
 151             Returns the number of relations or zero if there are none.
 152     */
 153 sal_Int32 SAL_CALL
 154     AccessibleRelationSetHelper::getRelationCount(  )
 155         throw (uno::RuntimeException, std::exception)
 156 {
 157     osl::MutexGuard aGuard (maMutex);
 158     return mpHelperImpl->getRelationCount();
 159 }
 160
 161     /** Returns the relation of this relation set that is specified by
 162         the given index.
 163
 164         @param nIndex
 165             This index specifies the relatio to return.
 166
 167         @return
 168             For a valid index, i.e. inside the range 0 to the number of
 169             relations minus one, the returned value is the requested
 170             relation.  If the index is invalid then the returned relation
 171             has the type INVALID.
 172
 173     */
 174  AccessibleRelation SAL_CALL
 175         AccessibleRelationSetHelper::getRelation( sal_Int32 nIndex )
 176             throw (lang::IndexOutOfBoundsException,
 177                     uno::RuntimeException, std::exception)
 178 {
 179     osl::MutexGuard aGuard (maMutex);
 180     return mpHelperImpl->getRelation(nIndex);
 181 }
 182
 183     /** Tests whether the relation set contains a relation matching the
 184         specified key.
 185
 186         @param aRelationType
 187             The type of relation to look for in this set of relations.  This
 188             has to be one of the constants of
 189             <type>AccessibleRelationType</type>.
 190
 191         @return
 192             Returns <TRUE/> if there is a (at least one) relation of the
 193             given type and <FALSE/> if there is no such relation in the set.
 194     */
 195 sal_Bool SAL_CALL
 196     AccessibleRelationSetHelper::containsRelation( sal_Int16 aRelationType )
 197         throw (uno::RuntimeException, std::exception)
 198 {
 199     osl::MutexGuard aGuard (maMutex);
 200     return mpHelperImpl->containsRelation(aRelationType);
 201 }
 202
 203     /** Retrieve and return the relation with the given relation type.
 204
 205         @param aRelationType
 206             The type of the relation to return.  This has to be one of the
 207             constants of <type>AccessibleRelationType</type>.
 208
 209         @return
 210             If a relation with the given type could be found than (a copy
 211             of) this relation is returned.  Otherwise a relation with the
 212             type INVALID is returned.
 213     */
 214 AccessibleRelation SAL_CALL
 215         AccessibleRelationSetHelper::getRelationByType( sal_Int16 aRelationType )
 216             throw (uno::RuntimeException, std::exception)
 217 {
 218     osl::MutexGuard aGuard (maMutex);
 219     return mpHelperImpl->getRelationByType(aRelationType);
 220 }
 221
 222 void AccessibleRelationSetHelper::AddRelation(const AccessibleRelation& rRelation)
 223             throw (uno::RuntimeException)
 224 {
 225     osl::MutexGuard aGuard (maMutex);
 226     mpHelperImpl->AddRelation(rRelation);
 227 }
 228
 229 //=====  XTypeProvider  =======================================================
 230
 231 uno::Sequence< ::com::sun::star::uno::Type>
 232     AccessibleRelationSetHelper::getTypes()
 233     throw (::com::sun::star::uno::RuntimeException, std::exception)
 234 {
 235     osl::MutexGuard aGuard (maMutex);
 236     const ::com::sun::star::uno::Type aTypeList[] = {
 237         cppu::UnoType<XAccessibleRelationSet>::get(),
 238         cppu::UnoType<lang::XTypeProvider>::get()
 239         };
 240     ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type>
 241         aTypeSequence (aTypeList, 2);
 242     return aTypeSequence;
 243 }
 244
 245 uno::Sequence<sal_Int8> SAL_CALL
 246     AccessibleRelationSetHelper::getImplementationId()
 247     throw (::com::sun::star::uno::RuntimeException, std::exception)
 248 {
 249     return css::uno::Sequence<sal_Int8>();
 250 }
 251
 252 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */