unotools/source/accessibility/accessiblestatesethelper.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/accessiblestatesethelper.hxx>
  21 #include <tools/debug.hxx>
  22 #include <comphelper/servicehelper.hxx>
  23
  24 // defines how many states the bitfield can contain
  25 // it has the size of 64 because I use a uInt64
  26 #define BITFIELDSIZE 64
  27
  28 using namespace ::utl;
  29 using namespace ::com::sun::star;
  30 using namespace ::com::sun::star::accessibility;
  31
  32 class AccessibleStateSetHelperImpl
  33 {
  34 public:
  35     AccessibleStateSetHelperImpl();
  36     AccessibleStateSetHelperImpl(const AccessibleStateSetHelperImpl& rImpl);
  37     ~AccessibleStateSetHelperImpl();
  38
  39     bool IsEmpty () const
  40         throw (uno::RuntimeException);
  41     bool Contains (sal_Int16 aState) const
  42         throw (uno::RuntimeException);
  43     uno::Sequence<sal_Int16> GetStates() const
  44         throw (uno::RuntimeException);
  45     void AddState(sal_Int16 aState)
  46         throw (uno::RuntimeException);
  47     void RemoveState(sal_Int16 aState)
  48         throw (uno::RuntimeException);
  49
  50     inline void AddStates( const sal_Int64 _nStates );
  51
  52 private:
  53     sal_uInt64 maStates;
  54 };
  55
  56 AccessibleStateSetHelperImpl::AccessibleStateSetHelperImpl()
  57     : maStates(0)
  58 {
  59 }
  60
  61 AccessibleStateSetHelperImpl::AccessibleStateSetHelperImpl(const AccessibleStateSetHelperImpl& rImpl)
  62     : maStates(rImpl.maStates)
  63 {
  64 }
  65
  66 AccessibleStateSetHelperImpl::~AccessibleStateSetHelperImpl()
  67 {
  68 }
  69
  70 inline bool AccessibleStateSetHelperImpl::IsEmpty () const
  71     throw (uno::RuntimeException)
  72 {
  73     return maStates == 0;
  74 }
  75
  76 inline bool AccessibleStateSetHelperImpl::Contains (sal_Int16 aState) const
  77     throw (uno::RuntimeException)
  78 {
  79     DBG_ASSERT(aState < BITFIELDSIZE, "the statesset is too small");
  80     sal_uInt64 aTempBitSet(1);
  81     aTempBitSet <<= aState;
  82     return ((aTempBitSet & maStates) != 0);
  83 }
  84
  85 inline uno::Sequence<sal_Int16> AccessibleStateSetHelperImpl::GetStates() const
  86     throw (uno::RuntimeException)
  87 {
  88     uno::Sequence<sal_Int16> aRet(BITFIELDSIZE);
  89     sal_Int16* pSeq = aRet.getArray();
  90     sal_Int16 nStateCount(0);
  91     for (sal_Int16 i = 0; i < BITFIELDSIZE; ++i)
  92         if (Contains(i))
  93         {
  94             *pSeq = i;
  95             ++pSeq;
  96             ++nStateCount;
  97         }
  98     aRet.realloc(nStateCount);
  99     return aRet;
 100 }
 101
 102 inline void AccessibleStateSetHelperImpl::AddStates( const sal_Int64 _nStates )
 103 {
 104     maStates |= _nStates;
 105 }
 106
 107 inline void AccessibleStateSetHelperImpl::AddState(sal_Int16 aState)
 108     throw (uno::RuntimeException)
 109 {
 110     DBG_ASSERT(aState < BITFIELDSIZE, "the statesset is too small");
 111     sal_uInt64 aTempBitSet(1);
 112     aTempBitSet <<= aState;
 113     maStates |= aTempBitSet;
 114 }
 115
 116 inline void AccessibleStateSetHelperImpl::RemoveState(sal_Int16 aState)
 117     throw (uno::RuntimeException)
 118 {
 119     DBG_ASSERT(aState < BITFIELDSIZE, "the statesset is too small");
 120     sal_uInt64 aTempBitSet(1);
 121     aTempBitSet <<= aState;
 122     aTempBitSet = ~aTempBitSet;
 123     maStates &= aTempBitSet;
 124 }
 125
 126 //=====  internal  ============================================================
 127
 128 AccessibleStateSetHelper::AccessibleStateSetHelper ()
 129     : mpHelperImpl(new AccessibleStateSetHelperImpl)
 130 {
 131 }
 132
 133 AccessibleStateSetHelper::AccessibleStateSetHelper ( const sal_Int64 _nInitialStates )
 134     : mpHelperImpl(new AccessibleStateSetHelperImpl)
 135 {
 136     mpHelperImpl->AddStates( _nInitialStates );
 137 }
 138
 139 AccessibleStateSetHelper::AccessibleStateSetHelper (const AccessibleStateSetHelper& rHelper)
 140     : cppu::WeakImplHelper1<XAccessibleStateSet>()
 141 {
 142     if (rHelper.mpHelperImpl)
 143         mpHelperImpl.reset(new AccessibleStateSetHelperImpl(*rHelper.mpHelperImpl));
 144     else
 145         mpHelperImpl.reset(new AccessibleStateSetHelperImpl());
 146 }
 147
 148 AccessibleStateSetHelper::~AccessibleStateSetHelper()
 149 {
 150 }
 151
 152 //=====  XAccessibleStateSet  ==============================================
 153
 154     /** Checks whether the current state set is empty.
 155
 156         @return
 157             Returns <TRUE/> if there is no state in this state set and
 158             <FALSE/> if there is at least one state set in it.
 159     */
 160 sal_Bool SAL_CALL AccessibleStateSetHelper::isEmpty ()
 161     throw (uno::RuntimeException, std::exception)
 162 {
 163     osl::MutexGuard aGuard (maMutex);
 164     return mpHelperImpl->IsEmpty();
 165 }
 166
 167     /** Checks if the given state is a member of the state set of this
 168         object.
 169
 170         @param aState
 171             The state for which to check membership.  This has to be one of
 172             the constants of <type>AccessibleStateType</type>.
 173
 174         @return
 175             Returns <TRUE/> if the given state is a member of this object's
 176             state set and <FALSE/> otherwise.
 177     */
 178 sal_Bool SAL_CALL AccessibleStateSetHelper::contains (sal_Int16 aState)
 179     throw (uno::RuntimeException, std::exception)
 180 {
 181     osl::MutexGuard aGuard (maMutex);
 182     return mpHelperImpl->Contains(aState);
 183 }
 184
 185     /** Checks if all of the given states are in this object's state
 186         set.
 187
 188         @param aStateSet
 189             This sequence of states is interpreted as set and every of its
 190             members, duplicates are ignored, is checked for membership in
 191             this object's state set.  Each state has to be one of the
 192             constants of <type>AccessibleStateType</type>.
 193
 194         @return
 195             Returns <TRUE/> if all states of the given state set are members
 196             of this object's state set.  <FALSE/> is returned if at least
 197             one of the states in the given state is not a member of this
 198             object's state set.
 199     */
 200 sal_Bool SAL_CALL AccessibleStateSetHelper::containsAll
 201     (const uno::Sequence<sal_Int16>& rStateSet)
 202     throw (uno::RuntimeException, std::exception)
 203 {
 204     osl::MutexGuard aGuard (maMutex);
 205     sal_Int32 nCount(rStateSet.getLength());
 206     const sal_Int16* pStates = rStateSet.getConstArray();
 207     sal_Int32 i = 0;
 208     bool bFound(true);
 209     while (i < nCount)
 210     {
 211         bFound = mpHelperImpl->Contains(pStates[i]);
 212         i++;
 213     }
 214     return bFound;
 215 }
 216
 217 uno::Sequence<sal_Int16> SAL_CALL AccessibleStateSetHelper::getStates()
 218     throw (uno::RuntimeException, std::exception)
 219 {
 220     osl::MutexGuard aGuard(maMutex);
 221     return mpHelperImpl->GetStates();
 222 }
 223
 224 void AccessibleStateSetHelper::AddState(sal_Int16 aState)
 225     throw (uno::RuntimeException)
 226 {
 227     osl::MutexGuard aGuard (maMutex);
 228     mpHelperImpl->AddState(aState);
 229 }
 230
 231 void AccessibleStateSetHelper::RemoveState(sal_Int16 aState)
 232     throw (uno::RuntimeException)
 233 {
 234     osl::MutexGuard aGuard (maMutex);
 235     mpHelperImpl->RemoveState(aState);
 236 }
 237
 238 //=====  XTypeProvider  =======================================================
 239
 240 uno::Sequence< css::uno::Type> AccessibleStateSetHelper::getTypes()
 241     throw (css::uno::RuntimeException, std::exception)
 242 {
 243     css::uno::Sequence< css::uno::Type> aTypeSequence {
 244         cppu::UnoType<XAccessibleStateSet>::get(),
 245         cppu::UnoType<lang::XTypeProvider>::get()
 246     };
 247     return aTypeSequence;
 248 }
 249
 250 uno::Sequence<sal_Int8> SAL_CALL AccessibleStateSetHelper::getImplementationId()
 251     throw (css::uno::RuntimeException, std::exception)
 252 {
 253     return css::uno::Sequence<sal_Int8>();
 254 }
 255
 256 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */