unotools/source/accessibility/accessiblestatesethelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: accessiblestatesethelper.cxx,v $
  10  * $Revision: 1.15 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_unotools.hxx"
  33
  34
  35 #include "unotools/accessiblestatesethelper.hxx"
  36 #include <rtl/uuid.h>
  37 #include <tools/debug.hxx>
  38
  39 #if 0
  40 #include <bitset>
  41 #endif
  42
  43 // defines how many states the bitfield can contain
  44 // it has the size of 64 because I use a uInt64
  45 #define BITFIELDSIZE 64
  46
  47 using namespace ::utl;
  48 using namespace ::rtl;
  49 using namespace ::com::sun::star;
  50 using namespace ::com::sun::star::accessibility;
  51
  52 class AccessibleStateSetHelperImpl
  53 {
  54 public:
  55     AccessibleStateSetHelperImpl();
  56     AccessibleStateSetHelperImpl(const AccessibleStateSetHelperImpl& rImpl);
  57     ~AccessibleStateSetHelperImpl();
  58
  59     sal_Bool IsEmpty ()
  60         throw (uno::RuntimeException);
  61     sal_Bool Contains (sal_Int16 aState)
  62         throw (uno::RuntimeException);
  63     uno::Sequence<sal_Int16> GetStates()
  64         throw (uno::RuntimeException);
  65     void AddState(sal_Int16 aState)
  66         throw (uno::RuntimeException);
  67     void RemoveState(sal_Int16 aState)
  68         throw (uno::RuntimeException);
  69     sal_Bool Compare(const AccessibleStateSetHelperImpl* pComparativeValue,
  70                         AccessibleStateSetHelperImpl* pOldStates,
  71                         AccessibleStateSetHelperImpl* pNewStates)
  72         throw (uno::RuntimeException);
  73
  74     inline void AddStates( const sal_Int64 _nStates ) SAL_THROW( ( ) );
  75
  76 private:
  77 #if 0
  78     ::std::bitset<BITFIELDSIZE> maStates; //Bitfield
  79 #endif
  80     sal_uInt64 maStates;
  81 };
  82
  83 AccessibleStateSetHelperImpl::AccessibleStateSetHelperImpl()
  84     : maStates(0)
  85 {
  86 }
  87
  88 AccessibleStateSetHelperImpl::AccessibleStateSetHelperImpl(const AccessibleStateSetHelperImpl& rImpl)
  89     : maStates(rImpl.maStates)
  90 {
  91 }
  92
  93 AccessibleStateSetHelperImpl::~AccessibleStateSetHelperImpl()
  94 {
  95 }
  96
  97 inline sal_Bool AccessibleStateSetHelperImpl::IsEmpty ()
  98     throw (uno::RuntimeException)
  99 {
 100 #if 0
 101     return maStates.none();
 102 #endif
 103     return maStates == 0;
 104 }
 105
 106 inline sal_Bool AccessibleStateSetHelperImpl::Contains (sal_Int16 aState)
 107     throw (uno::RuntimeException)
 108 {
 109     DBG_ASSERT(aState < BITFIELDSIZE, "the statesset is too small");
 110 #if 0
 111     return maStates.test(aState);
 112 #endif
 113     sal_uInt64 aTempBitSet(1);
 114     aTempBitSet <<= aState;
 115     return ((aTempBitSet & maStates) != 0);
 116 }
 117
 118 inline uno::Sequence<sal_Int16> AccessibleStateSetHelperImpl::GetStates()
 119     throw (uno::RuntimeException)
 120 {
 121     uno::Sequence<sal_Int16> aRet(BITFIELDSIZE);
 122     sal_Int16* pSeq = aRet.getArray();
 123     sal_Int16 nStateCount(0);
 124     for (sal_Int16 i = 0; i < BITFIELDSIZE; ++i)
 125         if (Contains(i))
 126         {
 127             *pSeq = i;
 128             ++pSeq;
 129             ++nStateCount;
 130         }
 131     aRet.realloc(nStateCount);
 132     return aRet;
 133 }
 134
 135 inline void AccessibleStateSetHelperImpl::AddStates( const sal_Int64 _nStates ) SAL_THROW( ( ) )
 136 {
 137     maStates |= _nStates;
 138 }
 139
 140 inline void AccessibleStateSetHelperImpl::AddState(sal_Int16 aState)
 141     throw (uno::RuntimeException)
 142 {
 143     DBG_ASSERT(aState < BITFIELDSIZE, "the statesset is too small");
 144 #if 0
 145     maStates.set(aState);
 146 #endif
 147     sal_uInt64 aTempBitSet(1);
 148     aTempBitSet <<= aState;
 149     maStates |= aTempBitSet;
 150 }
 151
 152 inline void AccessibleStateSetHelperImpl::RemoveState(sal_Int16 aState)
 153     throw (uno::RuntimeException)
 154 {
 155     DBG_ASSERT(aState < BITFIELDSIZE, "the statesset is too small");
 156 #if 0
 157     maStates.set(aState, 0);
 158 #endif
 159     sal_uInt64 aTempBitSet(1);
 160     aTempBitSet <<= aState;
 161     aTempBitSet = ~aTempBitSet;
 162     maStates &= aTempBitSet;
 163 }
 164
 165 inline sal_Bool AccessibleStateSetHelperImpl::Compare(
 166     const AccessibleStateSetHelperImpl* pComparativeValue,
 167         AccessibleStateSetHelperImpl* pOldStates,
 168         AccessibleStateSetHelperImpl* pNewStates)
 169     throw (uno::RuntimeException)
 170 {
 171     sal_Bool bResult(sal_False);
 172     if (pComparativeValue && pOldStates && pNewStates)
 173     {
 174         if (maStates == pComparativeValue->maStates)
 175             bResult = sal_True;
 176         else
 177         {
 178 #if 0
 179             std::bitset<BITFIELDSIZE> aTempBitSet(maStates);
 180 #endif
 181             sal_uInt64 aTempBitSet(maStates);
 182             aTempBitSet ^= pComparativeValue->maStates;
 183             pOldStates->maStates = aTempBitSet;
 184             pOldStates->maStates &= maStates;
 185             pNewStates->maStates = aTempBitSet;
 186             pNewStates->maStates &= pComparativeValue->maStates;
 187         }
 188     }
 189     return bResult;
 190 }
 191
 192
 193 //=====  internal  ============================================================
 194
 195 AccessibleStateSetHelper::AccessibleStateSetHelper ()
 196     : mpHelperImpl(NULL)
 197 {
 198     mpHelperImpl = new AccessibleStateSetHelperImpl();
 199 }
 200
 201 AccessibleStateSetHelper::AccessibleStateSetHelper ( const sal_Int64 _nInitialStates )
 202     : mpHelperImpl(NULL)
 203 {
 204     mpHelperImpl = new AccessibleStateSetHelperImpl();
 205     mpHelperImpl->AddStates( _nInitialStates );
 206 }
 207
 208 AccessibleStateSetHelper::AccessibleStateSetHelper (const AccessibleStateSetHelper& rHelper)
 209     : cppu::WeakImplHelper1<XAccessibleStateSet>()
 210     , mpHelperImpl(NULL)
 211 {
 212     if (rHelper.mpHelperImpl)
 213         mpHelperImpl = new AccessibleStateSetHelperImpl(*rHelper.mpHelperImpl);
 214     else
 215         mpHelperImpl = new AccessibleStateSetHelperImpl();
 216 }
 217
 218 AccessibleStateSetHelper::~AccessibleStateSetHelper(void)
 219 {
 220     delete mpHelperImpl;
 221 }
 222
 223 //=====  XAccessibleStateSet  ==============================================
 224
 225     /** Checks whether the current state set is empty.
 226
 227         @return
 228             Returns <TRUE/> if there is no state in this state set and
 229             <FALSE/> if there is at least one state set in it.
 230     */
 231 sal_Bool SAL_CALL AccessibleStateSetHelper::isEmpty ()
 232     throw (uno::RuntimeException)
 233 {
 234     ::vos::OGuard aGuard (maMutex);
 235     return mpHelperImpl->IsEmpty();
 236 }
 237
 238     /** Checks if the given state is a member of the state set of this
 239         object.
 240
 241         @param aState
 242             The state for which to check membership.  This has to be one of
 243             the constants of <type>AccessibleStateType</type>.
 244
 245         @return
 246             Returns <TRUE/> if the given state is a memeber of this object's
 247             state set and <FALSE/> otherwise.
 248     */
 249 sal_Bool SAL_CALL AccessibleStateSetHelper::contains (sal_Int16 aState)
 250     throw (uno::RuntimeException)
 251 {
 252     ::vos::OGuard aGuard (maMutex);
 253     return mpHelperImpl->Contains(aState);
 254 }
 255
 256     /** Checks if all of the given states are in this object's state
 257         set.
 258
 259         @param aStateSet
 260             This sequence of states is interpreted as set and every of its
 261             members, duplicates are ignored, is checked for membership in
 262             this object's state set.  Each state has to be one of the
 263             constants of <type>AccessibleStateType</type>.
 264
 265         @return
 266             Returns <TRUE/> if all states of the given state set are members
 267             of this object's state set.  <FALSE/> is returned if at least
 268             one of the states in the given state is not a member of this
 269             object's state set.
 270     */
 271 sal_Bool SAL_CALL AccessibleStateSetHelper::containsAll
 272     (const uno::Sequence<sal_Int16>& rStateSet)
 273     throw (uno::RuntimeException)
 274 {
 275     ::vos::OGuard aGuard (maMutex);
 276     sal_Int32 nCount(rStateSet.getLength());
 277     const sal_Int16* pStates = rStateSet.getConstArray();
 278     sal_Int32 i = 0;
 279     sal_Bool bFound(sal_True);
 280     while (i < nCount)
 281     {
 282         bFound = mpHelperImpl->Contains(pStates[i]);
 283         i++;
 284     }
 285     return bFound;
 286 }
 287
 288 uno::Sequence<sal_Int16> SAL_CALL AccessibleStateSetHelper::getStates()
 289     throw (uno::RuntimeException)
 290 {
 291     ::vos::OGuard aGuard(maMutex);
 292     return mpHelperImpl->GetStates();
 293 }
 294
 295 void AccessibleStateSetHelper::AddState(sal_Int16 aState)
 296     throw (uno::RuntimeException)
 297 {
 298     ::vos::OGuard aGuard (maMutex);
 299     mpHelperImpl->AddState(aState);
 300 }
 301
 302 void AccessibleStateSetHelper::RemoveState(sal_Int16 aState)
 303     throw (uno::RuntimeException)
 304 {
 305     ::vos::OGuard aGuard (maMutex);
 306     mpHelperImpl->RemoveState(aState);
 307 }
 308
 309 sal_Bool AccessibleStateSetHelper::Compare(
 310     const AccessibleStateSetHelper& rComparativeValue,
 311         AccessibleStateSetHelper& rOldStates,
 312         AccessibleStateSetHelper& rNewStates)
 313     throw (uno::RuntimeException)
 314 {
 315     ::vos::OGuard aGuard (maMutex);
 316     return mpHelperImpl->Compare(rComparativeValue.mpHelperImpl,
 317         rOldStates.mpHelperImpl, rNewStates.mpHelperImpl);
 318 }
 319
 320 //=====  XTypeProvider  =======================================================
 321
 322 uno::Sequence< ::com::sun::star::uno::Type>
 323     AccessibleStateSetHelper::getTypes (void)
 324     throw (::com::sun::star::uno::RuntimeException)
 325 {
 326     const ::com::sun::star::uno::Type aTypeList[] = {
 327         ::getCppuType((const uno::Reference<
 328             XAccessibleStateSet>*)0),
 329         ::getCppuType((const uno::Reference<
 330             lang::XTypeProvider>*)0)
 331         };
 332     ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type>
 333         aTypeSequence (aTypeList, 2);
 334     return aTypeSequence;
 335 }
 336
 337 uno::Sequence<sal_Int8> SAL_CALL
 338     AccessibleStateSetHelper::getImplementationId (void)
 339     throw (::com::sun::star::uno::RuntimeException)
 340 {
 341     ::vos::OGuard aGuard (maMutex);
 342     static uno::Sequence<sal_Int8> aId;
 343     if (aId.getLength() == 0)
 344     {
 345         aId.realloc (16);
 346         rtl_createUuid ((sal_uInt8 *)aId.getArray(), 0, sal_True);
 347     }
 348     return aId;
 349 }