vcl/aqua/source/a11y/documentfocuslistener.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: documentfocuslistener.cxx,v $
  10  *
  11  * $Revision: 1.3 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 #include "documentfocuslistener.hxx"
  33
  34 #ifndef _COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLEEVENTBROADCASTER_HPP_
  35 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  36 #endif
  37
  38 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_
  39 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  40 #endif
  41
  42 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_
  43 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  44 #endif
  45
  46 using namespace ::com::sun::star::accessibility;
  47 using namespace ::com::sun::star::lang;
  48 using namespace ::com::sun::star::uno;
  49
  50
  51 //------------------------------------------------------------------------------
  52
  53 DocumentFocusListener::DocumentFocusListener(AquaA11yFocusTracker& rTracker) :
  54     m_aFocusTracker(rTracker)
  55 {
  56 }
  57
  58 //------------------------------------------------------------------------------
  59
  60 void SAL_CALL
  61 DocumentFocusListener::disposing( const EventObject& aEvent )
  62     throw (RuntimeException)
  63 {
  64     // Unref the object here, but do not remove as listener since the object
  65     // might no longer be in a state that safely allows this.
  66     if( aEvent.Source.is() )
  67         m_aRefList.erase(aEvent.Source);
  68 }
  69
  70 //------------------------------------------------------------------------------
  71
  72 void SAL_CALL
  73 DocumentFocusListener::notifyEvent( const AccessibleEventObject& aEvent )
  74     throw( RuntimeException )
  75 {
  76     switch( aEvent.EventId )
  77     {
  78         case AccessibleEventId::STATE_CHANGED:
  79             try
  80             {
  81                 sal_Int16 nState = AccessibleStateType::INVALID;
  82                 aEvent.NewValue >>= nState;
  83
  84                 if( AccessibleStateType::FOCUSED == nState )
  85                     m_aFocusTracker.setFocusedObject( getAccessible(aEvent) );
  86             }
  87             catch(IndexOutOfBoundsException e)
  88             {
  89                 OSL_TRACE("Focused object has invalid index in parent");
  90             }
  91             break;
  92
  93         case AccessibleEventId::CHILD:
  94         {
  95             Reference< XAccessible > xChild;
  96             if( (aEvent.OldValue >>= xChild) && xChild.is() )
  97                 detachRecursive(xChild);
  98
  99             if( (aEvent.NewValue >>= xChild) && xChild.is() )
 100                 attachRecursive(xChild);
 101         }
 102             break;
 103
 104         case AccessibleEventId::INVALIDATE_ALL_CHILDREN:
 105 /*        {
 106             Reference< XAccessible > xAccessible( getAccessible(aEvent) );
 107             detachRecursive(xAccessible);
 108             attachRecursive(xAccessible);
 109         }
 110 */
 111             OSL_TRACE( "Invalidate all children called\n" );
 112             break;
 113         default:
 114             break;
 115     }
 116 }
 117
 118 //------------------------------------------------------------------------------
 119
 120 Reference< XAccessible > DocumentFocusListener::getAccessible(const EventObject& aEvent )
 121     throw (IndexOutOfBoundsException, RuntimeException)
 122 {
 123     Reference< XAccessible > xAccessible(aEvent.Source, UNO_QUERY);
 124
 125     if( xAccessible.is() )
 126         return xAccessible;
 127
 128     Reference< XAccessibleContext > xContext(aEvent.Source, UNO_QUERY);
 129
 130     if( xContext.is() )
 131     {
 132         Reference< XAccessible > xParent( xContext->getAccessibleParent() );
 133         if( xParent.is() )
 134         {
 135             Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 136             if( xParentContext.is() )
 137             {
 138                 return xParentContext->getAccessibleChild( xContext->getAccessibleIndexInParent() );
 139             }
 140         }
 141     }
 142
 143     return Reference< XAccessible >();
 144 }
 145
 146 //------------------------------------------------------------------------------
 147
 148 void DocumentFocusListener::attachRecursive(const Reference< XAccessible >& xAccessible)
 149     throw (IndexOutOfBoundsException, RuntimeException)
 150 {
 151     Reference< XAccessibleContext > xContext = xAccessible->getAccessibleContext();
 152
 153     if( xContext.is() )
 154         attachRecursive(xAccessible, xContext);
 155 }
 156
 157 //------------------------------------------------------------------------------
 158
 159 void DocumentFocusListener::attachRecursive(
 160     const Reference< XAccessible >& xAccessible,
 161     const Reference< XAccessibleContext >& xContext
 162 )  throw (IndexOutOfBoundsException, RuntimeException)
 163 {
 164     if( xContext.is() )
 165     {
 166         Reference< XAccessibleStateSet > xStateSet = xContext->getAccessibleStateSet();
 167
 168         if( xStateSet.is() )
 169             attachRecursive(xAccessible, xContext, xStateSet);
 170     }
 171 }
 172
 173 //------------------------------------------------------------------------------
 174
 175 void DocumentFocusListener::attachRecursive(
 176     const Reference< XAccessible >& xAccessible,
 177     const Reference< XAccessibleContext >& xContext,
 178     const Reference< XAccessibleStateSet >& xStateSet
 179 ) throw (IndexOutOfBoundsException,RuntimeException)
 180 {
 181     if( xStateSet->contains(AccessibleStateType::FOCUSED ) )
 182         m_aFocusTracker.setFocusedObject( xAccessible );
 183
 184     Reference< XAccessibleEventBroadcaster > xBroadcaster =
 185         Reference< XAccessibleEventBroadcaster >(xContext, UNO_QUERY);
 186
 187     // If not already done, add the broadcaster to the list and attach as listener.
 188     if( xBroadcaster.is() && m_aRefList.insert(xBroadcaster).second )
 189     {
 190         xBroadcaster->addEventListener(static_cast< XAccessibleEventListener *>(this));
 191
 192         if( ! xStateSet->contains(AccessibleStateType::MANAGES_DESCENDANTS ) )
 193         {
 194             sal_Int32 n, nmax = xContext->getAccessibleChildCount();
 195             for( n = 0; n < nmax; n++ )
 196             {
 197                 Reference< XAccessible > xChild( xContext->getAccessibleChild( n ) );
 198
 199                 if( xChild.is() )
 200                     attachRecursive(xChild);
 201             }
 202         }
 203     }
 204 }
 205
 206 //------------------------------------------------------------------------------
 207
 208 void DocumentFocusListener::detachRecursive(const Reference< XAccessible >& xAccessible)
 209     throw (IndexOutOfBoundsException, RuntimeException)
 210 {
 211     Reference< XAccessibleContext > xContext = xAccessible->getAccessibleContext();
 212
 213     if( xContext.is() )
 214         detachRecursive(xAccessible, xContext);
 215 }
 216
 217 //------------------------------------------------------------------------------
 218
 219 void DocumentFocusListener::detachRecursive(
 220     const Reference< XAccessible >& xAccessible,
 221     const Reference< XAccessibleContext >& xContext
 222 )  throw (IndexOutOfBoundsException, RuntimeException)
 223 {
 224     Reference< XAccessibleStateSet > xStateSet = xContext->getAccessibleStateSet();
 225
 226     if( xStateSet.is() )
 227         detachRecursive(xAccessible, xContext, xStateSet);
 228 }
 229
 230 //------------------------------------------------------------------------------
 231
 232 void DocumentFocusListener::detachRecursive(
 233     const Reference< XAccessible >&,
 234     const Reference< XAccessibleContext >& xContext,
 235     const Reference< XAccessibleStateSet >& xStateSet
 236 ) throw (IndexOutOfBoundsException, RuntimeException)
 237 {
 238     Reference< XAccessibleEventBroadcaster > xBroadcaster =
 239         Reference< XAccessibleEventBroadcaster >(xContext, UNO_QUERY);
 240
 241     if( xBroadcaster.is() && 0 < m_aRefList.erase(xBroadcaster) )
 242     {
 243         xBroadcaster->removeEventListener(static_cast< XAccessibleEventListener *>(this));
 244
 245         if( ! xStateSet->contains(AccessibleStateType::MANAGES_DESCENDANTS ) )
 246         {
 247             sal_Int32 n, nmax = xContext->getAccessibleChildCount();
 248             for( n = 0; n < nmax; n++ )
 249             {
 250                 Reference< XAccessible > xChild( xContext->getAccessibleChild( n ) );
 251
 252                 if( xChild.is() )
 253                     detachRecursive(xChild);
 254             }
 255         }
 256     }
 257 }