svx/source/accessibility/AccessibleParaManager.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: AccessibleParaManager.cxx,v $
  10  * $Revision: 1.16 $
  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_svx.hxx"
  33
  34 //------------------------------------------------------------------------
  35 //
  36 // Global header
  37 //
  38 //------------------------------------------------------------------------
  39 #include <com/sun/star/uno/Any.hxx>
  40 #include <com/sun/star/uno/Reference.hxx>
  41 #include <cppuhelper/weakref.hxx>
  42 #include <com/sun/star/accessibility/XAccessible.hpp>
  43 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  44
  45 //------------------------------------------------------------------------
  46 //
  47 // Project-local header
  48 //
  49 //------------------------------------------------------------------------
  50
  51 #include "unoedhlp.hxx"
  52 #include "unopracc.hxx"
  53 #include <svx/unoedsrc.hxx>
  54 #include "AccessibleParaManager.hxx"
  55 #include "AccessibleEditableTextPara.hxx"
  56
  57
  58 using namespace ::com::sun::star;
  59 using namespace ::com::sun::star::accessibility;
  60
  61
  62
  63 namespace accessibility
  64 {
  65     AccessibleParaManager::AccessibleParaManager() :
  66         maChildren(1),
  67         maEEOffset( 0, 0 ),
  68         mnFocusedChild( -1 ),
  69         mbActive( sal_False )
  70     {
  71     }
  72
  73     AccessibleParaManager::~AccessibleParaManager()
  74     {
  75         // owner is responsible for possible child defuncs
  76     }
  77
  78     void AccessibleParaManager::SetAdditionalChildStates( const VectorOfStates& rChildStates )
  79     {
  80         maChildStates = rChildStates;
  81     }
  82
  83     const AccessibleParaManager::VectorOfStates& AccessibleParaManager::GetAdditionalChildStates() const
  84     {
  85         return maChildStates;
  86     }
  87
  88     void AccessibleParaManager::SetNum( sal_Int32 nNumParas )
  89     {
  90         if( (size_t)nNumParas < maChildren.size() )
  91             Release( nNumParas, maChildren.size() );
  92
  93         maChildren.resize( nNumParas );
  94
  95         if( mnFocusedChild >= nNumParas )
  96             mnFocusedChild = -1;
  97     }
  98
  99     sal_uInt32 AccessibleParaManager::GetNum() const
 100     {
 101         return maChildren.size();
 102     }
 103
 104     AccessibleParaManager::VectorOfChildren::iterator AccessibleParaManager::begin()
 105     {
 106         return maChildren.begin();
 107     }
 108
 109     AccessibleParaManager::VectorOfChildren::iterator AccessibleParaManager::end()
 110     {
 111         return maChildren.end();
 112     }
 113
 114     AccessibleParaManager::VectorOfChildren::const_iterator AccessibleParaManager::begin() const
 115     {
 116         return maChildren.begin();
 117     }
 118
 119     AccessibleParaManager::VectorOfChildren::const_iterator AccessibleParaManager::end() const
 120     {
 121         return maChildren.end();
 122     }
 123
 124     void AccessibleParaManager::Release( sal_uInt32 nPara )
 125     {
 126         DBG_ASSERT( maChildren.size() > nPara, "AccessibleParaManager::Release: invalid index" );
 127
 128         if( maChildren.size() > nPara )
 129         {
 130             ShutdownPara( GetChild( nPara ) );
 131
 132             // clear reference and rect
 133             maChildren[ nPara ] = WeakChild();
 134         }
 135     }
 136
 137     void AccessibleParaManager::FireEvent( sal_uInt32 nPara,
 138                                            const sal_Int16 nEventId,
 139                                            const uno::Any& rNewValue,
 140                                            const uno::Any& rOldValue ) const
 141     {
 142         DBG_ASSERT( maChildren.size() > nPara, "AccessibleParaManager::FireEvent: invalid index" );
 143
 144         if( maChildren.size() > nPara )
 145         {
 146             WeakPara::HardRefType maChild( GetChild( nPara ).first.get() );
 147             if( maChild.is() )
 148                 maChild->FireEvent( nEventId, rNewValue, rOldValue );
 149         }
 150     }
 151
 152     sal_Bool AccessibleParaManager::IsReferencable( WeakPara::HardRefType aChild )
 153     {
 154         return aChild.is();
 155     }
 156
 157     sal_Bool AccessibleParaManager::IsReferencable( sal_uInt32 nChild ) const
 158     {
 159         DBG_ASSERT( maChildren.size() > nChild, "AccessibleParaManager::IsReferencable: invalid index" );
 160
 161         if( maChildren.size() > nChild )
 162         {
 163             // retrieve hard reference from weak one
 164             return IsReferencable( GetChild( nChild ).first.get() );
 165         }
 166         else
 167         {
 168             return sal_False;
 169         }
 170     }
 171
 172     AccessibleParaManager::WeakChild AccessibleParaManager::GetChild( sal_uInt32 nParagraphIndex ) const
 173     {
 174         DBG_ASSERT( maChildren.size() > nParagraphIndex, "AccessibleParaManager::GetChild: invalid index" );
 175
 176         if( maChildren.size() > nParagraphIndex )
 177         {
 178             return maChildren[ nParagraphIndex ];
 179         }
 180         else
 181         {
 182             return WeakChild();
 183         }
 184     }
 185
 186     AccessibleParaManager::Child AccessibleParaManager::CreateChild( sal_Int32                                                          nChild,
 187                                                                      const uno::Reference< XAccessible >&       xFrontEnd,
 188                                                                      SvxEditSourceAdapter&                                      rEditSource,
 189                                                                      sal_uInt32                                                         nParagraphIndex )
 190     {
 191         DBG_ASSERT( maChildren.size() > nParagraphIndex, "AccessibleParaManager::CreateChild: invalid index" );
 192
 193         if( maChildren.size() > nParagraphIndex )
 194         {
 195             // retrieve hard reference from weak one
 196             WeakPara::HardRefType aChild( GetChild( nParagraphIndex ).first.get() );
 197
 198             if( !IsReferencable( nParagraphIndex ) )
 199             {
 200                 // there is no hard reference available, create object then
 201                 // --> OD 2006-01-11 #i27138#
 202                 AccessibleEditableTextPara* pChild = new AccessibleEditableTextPara( xFrontEnd, this );
 203                 // <--
 204                 uno::Reference< XAccessible > xChild( static_cast< ::cppu::OWeakObject* > (pChild), uno::UNO_QUERY );
 205
 206                 if( !xChild.is() )
 207                     throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Child creation failed")), xFrontEnd);
 208
 209                 aChild = WeakPara::HardRefType( xChild, pChild );
 210
 211                 InitChild( *aChild, rEditSource, nChild, nParagraphIndex );
 212
 213                 maChildren[ nParagraphIndex ] = WeakChild( aChild, pChild->getBounds() );
 214             }
 215
 216             return Child( aChild.getRef(), GetChild( nParagraphIndex ).second );
 217         }
 218         else
 219         {
 220             return Child();
 221         }
 222     }
 223
 224     void AccessibleParaManager::SetEEOffset( const Point& rOffset )
 225     {
 226         maEEOffset = rOffset;
 227
 228         MemFunAdapter< const Point& > aAdapter( &::accessibility::AccessibleEditableTextPara::SetEEOffset, rOffset );
 229         ::std::for_each( begin(), end(), aAdapter );
 230     }
 231
 232     void AccessibleParaManager::SetActive( sal_Bool bActive )
 233     {
 234         mbActive = bActive;
 235
 236         if( bActive )
 237         {
 238             SetState( AccessibleStateType::ACTIVE );
 239             SetState( AccessibleStateType::EDITABLE );
 240         }
 241         else
 242         {
 243             UnSetState( AccessibleStateType::ACTIVE );
 244             UnSetState( AccessibleStateType::EDITABLE );
 245         }
 246     }
 247
 248     void AccessibleParaManager::SetFocus( sal_Int32 nChild )
 249     {
 250         if( mnFocusedChild != -1 )
 251             UnSetState( mnFocusedChild, AccessibleStateType::FOCUSED );
 252
 253         mnFocusedChild = nChild;
 254
 255         if( mnFocusedChild != -1 )
 256             SetState( mnFocusedChild, AccessibleStateType::FOCUSED );
 257     }
 258
 259     void AccessibleParaManager::InitChild( AccessibleEditableTextPara&  rChild,
 260                                            SvxEditSourceAdapter&                rEditSource,
 261                                            sal_Int32                                    nChild,
 262                                            sal_uInt32                                   nParagraphIndex ) const
 263     {
 264         rChild.SetEditSource( &rEditSource );
 265         rChild.SetIndexInParent( nChild );
 266         rChild.SetParagraphIndex( nParagraphIndex );
 267
 268         rChild.SetEEOffset( maEEOffset );
 269
 270         if( mbActive )
 271         {
 272             rChild.SetState( AccessibleStateType::ACTIVE );
 273             rChild.SetState( AccessibleStateType::EDITABLE );
 274         }
 275
 276         if( mnFocusedChild == static_cast<sal_Int32>(nParagraphIndex) )
 277             rChild.SetState( AccessibleStateType::FOCUSED );
 278
 279         // add states passed from outside
 280         for( VectorOfStates::const_iterator aIt = maChildStates.begin(), aEnd = maChildStates.end(); aIt != aEnd; ++aIt )
 281             rChild.SetState( *aIt );
 282     }
 283
 284     void AccessibleParaManager::SetState( sal_Int32 nChild, const sal_Int16 nStateId )
 285     {
 286         MemFunAdapter< const sal_Int16 > aFunc( &AccessibleEditableTextPara::SetState,
 287                                                 nStateId );
 288         aFunc( GetChild(nChild) );
 289     }
 290
 291     void AccessibleParaManager::SetState( const sal_Int16 nStateId )
 292     {
 293         ::std::for_each( begin(), end(),
 294                          MemFunAdapter< const sal_Int16 >( &AccessibleEditableTextPara::SetState,
 295                                                            nStateId ) );
 296     }
 297
 298     void AccessibleParaManager::UnSetState( sal_Int32 nChild, const sal_Int16 nStateId )
 299     {
 300         MemFunAdapter< const sal_Int16 > aFunc( &AccessibleEditableTextPara::UnSetState,
 301                                                 nStateId );
 302         aFunc( GetChild(nChild) );
 303     }
 304
 305     void AccessibleParaManager::UnSetState( const sal_Int16 nStateId )
 306     {
 307         ::std::for_each( begin(), end(),
 308                          MemFunAdapter< const sal_Int16 >( &AccessibleEditableTextPara::UnSetState,
 309                                                            nStateId ) );
 310     }
 311
 312     void AccessibleParaManager::SetEditSource( SvxEditSourceAdapter* pEditSource )
 313     {
 314         MemFunAdapter< SvxEditSourceAdapter* > aAdapter( &::accessibility::AccessibleEditableTextPara::SetEditSource, pEditSource );
 315         ::std::for_each( begin(), end(), aAdapter );
 316     }
 317
 318     // not generic yet, no arguments...
 319     class AccessibleParaManager_DisposeChildren : public ::std::unary_function< ::accessibility::AccessibleEditableTextPara&, void >
 320     {
 321     public:
 322         AccessibleParaManager_DisposeChildren() {}
 323         void operator()( ::accessibility::AccessibleEditableTextPara& rPara )
 324         {
 325             rPara.Dispose();
 326         }
 327     };
 328
 329     void AccessibleParaManager::Dispose()
 330     {
 331         AccessibleParaManager_DisposeChildren aFunctor;
 332
 333         ::std::for_each( begin(), end(),
 334                          WeakChildAdapter< AccessibleParaManager_DisposeChildren > (aFunctor) );
 335     }
 336
 337     // not generic yet, too many method arguments...
 338     class StateChangeEvent : public ::std::unary_function< ::accessibility::AccessibleEditableTextPara&, void >
 339     {
 340     public:
 341         typedef void return_type;
 342         StateChangeEvent( const sal_Int16 nEventId,
 343                           const uno::Any& rNewValue,
 344                           const uno::Any& rOldValue ) :
 345             mnEventId( nEventId ),
 346             mrNewValue( rNewValue ),
 347             mrOldValue( rOldValue ) {}
 348         void operator()( ::accessibility::AccessibleEditableTextPara& rPara )
 349         {
 350             rPara.FireEvent( mnEventId, mrNewValue, mrOldValue );
 351         }
 352
 353     private:
 354         const sal_Int16 mnEventId;
 355         const uno::Any& mrNewValue;
 356         const uno::Any& mrOldValue;
 357     };
 358
 359     void AccessibleParaManager::FireEvent( sal_uInt32 nStartPara,
 360                                            sal_uInt32 nEndPara,
 361                                            const sal_Int16 nEventId,
 362                                            const uno::Any& rNewValue,
 363                                            const uno::Any& rOldValue ) const
 364     {
 365         DBG_ASSERT( maChildren.size() > nStartPara &&
 366                     maChildren.size() >= nEndPara , "AccessibleParaManager::FireEvent: invalid index" );
 367
 368         if( maChildren.size() > nStartPara &&
 369             maChildren.size() >= nEndPara )
 370         {
 371             VectorOfChildren::const_iterator front = maChildren.begin();
 372             VectorOfChildren::const_iterator back = front;
 373
 374             ::std::advance( front, nStartPara );
 375             ::std::advance( back, nEndPara );
 376
 377             StateChangeEvent aFunctor( nEventId, rNewValue, rOldValue );
 378
 379             ::std::for_each( front, back, AccessibleParaManager::WeakChildAdapter< StateChangeEvent >( aFunctor ) );
 380         }
 381     }
 382
 383     class ReleaseChild : public ::std::unary_function< const AccessibleParaManager::WeakChild&, AccessibleParaManager::WeakChild >
 384     {
 385     public:
 386         AccessibleParaManager::WeakChild operator()( const AccessibleParaManager::WeakChild& rPara )
 387         {
 388             AccessibleParaManager::ShutdownPara( rPara );
 389
 390             // clear reference
 391             return AccessibleParaManager::WeakChild();
 392         }
 393     };
 394
 395     void AccessibleParaManager::Release( sal_uInt32 nStartPara, sal_uInt32 nEndPara )
 396     {
 397         DBG_ASSERT( maChildren.size() > nStartPara &&
 398                     maChildren.size() >= nEndPara, "AccessibleParaManager::Release: invalid index" );
 399
 400         if( maChildren.size() > nStartPara &&
 401             maChildren.size() >= nEndPara )
 402         {
 403             VectorOfChildren::iterator front = maChildren.begin();
 404             VectorOfChildren::iterator back = front;
 405
 406             ::std::advance( front, nStartPara );
 407             ::std::advance( back, nEndPara );
 408
 409             ::std::transform( front, back, front, ReleaseChild() );
 410         }
 411     }
 412
 413     void AccessibleParaManager::ShutdownPara( const WeakChild& rChild )
 414     {
 415         WeakPara::HardRefType aChild( rChild.first.get() );
 416
 417         if( IsReferencable( aChild ) )
 418             aChild->SetEditSource( NULL );
 419     }
 420
 421 }
 422
 423 //------------------------------------------------------------------------