svx/source/accessibility/AccessibleTextHelper.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
  21 // Global header
  22
  23
  24 #include <memory>
  25 #include <utility>
  26 #include <algorithm>
  27 #include <deque>
  28 #include <osl/mutex.hxx>
  29 #include <sal/log.hxx>
  30 #include <com/sun/star/uno/Any.hxx>
  31 #include <com/sun/star/uno/Reference.hxx>
  32 #include <cppuhelper/weakref.hxx>
  33 #include <com/sun/star/awt/Point.hpp>
  34 #include <com/sun/star/awt/Rectangle.hpp>
  35 #include <com/sun/star/lang/DisposedException.hpp>
  36 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  37 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  38 #include <com/sun/star/accessibility/XAccessible.hpp>
  39 #include <com/sun/star/accessibility/XAccessibleContext.hpp>
  40 #include <com/sun/star/accessibility/XAccessibleComponent.hpp>
  41 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  42 #include <comphelper/accessibleeventnotifier.hxx>
  43 #include <unotools/accessiblestatesethelper.hxx>
  44 #include <vcl/svapp.hxx>
  45 #include <vcl/textdata.hxx>
  46 #include <vcl/unohelp.hxx>
  47 #include <sfx2/viewfrm.hxx>
  48 #include <sfx2/viewsh.hxx>
  49
  50
  51 // Project-local header
  52
  53
  54 #include "AccessibleTextEventQueue.hxx"
  55 #include <svx/AccessibleTextHelper.hxx>
  56 #include <svx/unoshape.hxx>
  57 #include <editeng/unolingu.hxx>
  58 #include <editeng/unotext.hxx>
  59
  60 #include <editeng/unoedhlp.hxx>
  61 #include <editeng/unopracc.hxx>
  62 #include <editeng/unoedprx.hxx>
  63 #include <editeng/AccessibleParaManager.hxx>
  64 #include <editeng/AccessibleEditableTextPara.hxx>
  65 #include <svx/svdmodel.hxx>
  66 #include <svx/svdpntv.hxx>
  67 #include <cell.hxx>
  68 #include "../table/accessiblecell.hxx"
  69 #include <editeng/editdata.hxx>
  70 #include <editeng/editeng.hxx>
  71 #include <editeng/editview.hxx>
  72 #include <tools/debug.hxx>
  73 #include <tools/diagnose_ex.h>
  74
  75 using namespace ::com::sun::star;
  76 using namespace ::com::sun::star::accessibility;
  77
  78 namespace accessibility
  79 {
  80
  81 // AccessibleTextHelper_Impl declaration
  82
  83     template < typename first_type, typename second_type >
  84         static ::std::pair< first_type, second_type > makeSortedPair( first_type   first,
  85                                                                                  second_type    second  )
  86     {
  87         if( first > second )
  88             return ::std::make_pair( second, first );
  89         else
  90             return ::std::make_pair( first, second );
  91     }
  92
  93     class AccessibleTextHelper_Impl : public SfxListener
  94     {
  95     public:
  96         typedef ::std::vector< sal_Int16 > VectorOfStates;
  97
  98         // receive pointer to our frontend class and view window
  99         AccessibleTextHelper_Impl();
 100         virtual ~AccessibleTextHelper_Impl() override;
 101
 102         // XAccessibleContext child handling methods
 103         sal_Int32 getAccessibleChildCount() const;
 104         uno::Reference< XAccessible > getAccessibleChild( sal_Int32 i );
 105
 106         // XAccessibleEventBroadcaster child related methods
 107         void addAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener );
 108         void removeAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener );
 109
 110         // XAccessibleComponent child related methods
 111         uno::Reference< XAccessible > getAccessibleAtPoint( const awt::Point& aPoint );
 112
 113         SvxEditSourceAdapter& GetEditSource() const;
 114
 115         void SetEditSource( ::std::unique_ptr< SvxEditSource > && pEditSource );
 116
 117         void SetEventSource( const uno::Reference< XAccessible >& rInterface )
 118         {
 119             mxFrontEnd = rInterface;
 120         }
 121
 122         void SetOffset( const Point& );
 123         Point GetOffset() const
 124         {
 125             ::osl::MutexGuard aGuard( maMutex ); Point aPoint( maOffset );
 126             return aPoint;
 127         }
 128
 129         void SetStartIndex( sal_Int32 nOffset );
 130         sal_Int32 GetStartIndex() const
 131         {
 132             // Strictly correct only with locked solar mutex, // but
 133             // here we rely on the fact that sal_Int32 access is
 134             // atomic
 135             return mnStartIndex;
 136         }
 137
 138         void SetAdditionalChildStates( const VectorOfStates& rChildStates );
 139
 140         void Dispose();
 141
 142         // do NOT hold object mutex when calling this! Danger of deadlock
 143         void FireEvent( const sal_Int16 nEventId, const uno::Any& rNewValue = uno::Any(), const uno::Any& rOldValue = uno::Any() ) const;
 144         void FireEvent( const AccessibleEventObject& rEvent ) const;
 145
 146         void SetFocus( bool bHaveFocus );
 147         bool HaveFocus()
 148         {
 149             // No locking of solar mutex here, since we rely on the fact
 150             // that sal_Bool access is atomic
 151             return mbThisHasFocus;
 152         }
 153         void SetChildFocus( sal_Int32 nChild, bool bHaveFocus );
 154         void SetShapeFocus( bool bHaveFocus );
 155         void ChangeChildFocus( sal_Int32 nNewChild );
 156
 157 #ifdef DBG_UTIL
 158         void CheckInvariants() const;
 159 #endif
 160
 161         // checks all children for visibility, throws away invisible ones
 162         void UpdateVisibleChildren( bool bBroadcastEvents=true );
 163
 164         // check all children for changes in position and size
 165         void UpdateBoundRect();
 166
 167         // calls SetSelection on the forwarder and updates maLastSelection
 168         // cache.
 169         void UpdateSelection();
 170
 171     private:
 172
 173         // Process event queue
 174         void ProcessQueue();
 175
 176         // syntactic sugar for FireEvent
 177         void GotPropertyEvent( const uno::Any& rNewValue, const sal_Int16 nEventId ) const { FireEvent( nEventId, rNewValue ); }
 178
 179         // shutdown usage of current edit source on myself and the children.
 180         void ShutdownEditSource();
 181
 182         void ParagraphsMoved( sal_Int32 nFirst, sal_Int32 nMiddle, sal_Int32 nLast );
 183
 184         virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
 185
 186         int getNotifierClientId() const { return mnNotifierClientId; }
 187
 188         // lock solar mutex before
 189         SvxTextForwarder& GetTextForwarder() const;
 190         // lock solar mutex before
 191         SvxViewForwarder& GetViewForwarder() const;
 192         // lock solar mutex before
 193         SvxEditViewForwarder& GetEditViewForwarder() const;
 194
 195         // are we in edit mode?
 196         bool IsActive() const;
 197
 198         // our frontend class (the one implementing the actual
 199         // interface). That's not necessarily the one containing the impl
 200         // pointer!
 201         uno::Reference< XAccessible > mxFrontEnd;
 202
 203         // a wrapper for the text forwarders (guarded by solar mutex)
 204         mutable SvxEditSourceAdapter maEditSource;
 205
 206         // store last selection (to correctly report selection changes, guarded by solar mutex)
 207         ESelection maLastSelection;
 208
 209         // cache range of visible children (guarded by solar mutex)
 210         sal_Int32 mnFirstVisibleChild;
 211         sal_Int32 mnLastVisibleChild;
 212
 213         // offset to add to all our children (unguarded, relying on
 214         // the fact that sal_Int32 access is atomic)
 215         sal_Int32 mnStartIndex;
 216
 217         // the object handling our children (guarded by solar mutex)
 218         ::accessibility::AccessibleParaManager maParaManager;
 219
 220         // Queued events from Notify() (guarded by solar mutex)
 221         AccessibleTextEventQueue maEventQueue;
 222
 223         // spin lock to prevent notify in notify (guarded by solar mutex)
 224         bool mbInNotify;
 225
 226         // whether the object or its children has the focus set (guarded by solar mutex)
 227         bool mbGroupHasFocus;
 228
 229         // whether we (this object) has the focus set (guarded by solar mutex)
 230         bool mbThisHasFocus;
 231
 232         mutable ::osl::Mutex maMutex;
 233
 234         /// our current offset to the containing shape/cell (guarded by maMutex)
 235         Point maOffset;
 236
 237         /// client Id from AccessibleEventNotifier
 238         int mnNotifierClientId;
 239     };
 240
 241     AccessibleTextHelper_Impl::AccessibleTextHelper_Impl() :
 242         maLastSelection( EE_PARA_NOT_FOUND,EE_INDEX_NOT_FOUND,EE_PARA_NOT_FOUND,EE_INDEX_NOT_FOUND ),
 243         mnFirstVisibleChild( -1 ),
 244         mnLastVisibleChild( -2 ),
 245         mnStartIndex( 0 ),
 246         mbInNotify( false ),
 247         mbGroupHasFocus( false ),
 248         mbThisHasFocus( false ),
 249         maOffset(0,0),
 250         // well, that's strictly exception safe, though not really
 251         // robust. We rely on the fact that this member is constructed
 252         // last, and that the constructor body is empty, thus no
 253         // chance for exceptions once the Id is fetched. Nevertheless,
 254         // normally should employ RAII here...
 255         mnNotifierClientId(::comphelper::AccessibleEventNotifier::registerClient())
 256     {
 257         SAL_INFO("svx", "received ID: " << mnNotifierClientId );
 258     }
 259
 260     AccessibleTextHelper_Impl::~AccessibleTextHelper_Impl()
 261     {
 262         SolarMutexGuard aGuard;
 263
 264         try
 265         {
 266             // call Dispose here, too, since we've some resources not
 267             // automatically freed otherwise
 268             Dispose();
 269         }
 270         catch( const uno::Exception& ) {}
 271     }
 272
 273     SvxTextForwarder& AccessibleTextHelper_Impl::GetTextForwarder() const
 274     {
 275         if( !maEditSource.IsValid() )
 276             throw uno::RuntimeException("Unknown edit source", mxFrontEnd);
 277
 278         SvxTextForwarder* pTextForwarder = maEditSource.GetTextForwarder();
 279
 280         if( !pTextForwarder )
 281             throw uno::RuntimeException("Unable to fetch text forwarder, model might be dead", mxFrontEnd);
 282
 283         if( !pTextForwarder->IsValid() )
 284             throw uno::RuntimeException("Text forwarder is invalid, model might be dead", mxFrontEnd);
 285
 286         return *pTextForwarder;
 287     }
 288
 289     SvxViewForwarder& AccessibleTextHelper_Impl::GetViewForwarder() const
 290     {
 291         if( !maEditSource.IsValid() )
 292             throw uno::RuntimeException("Unknown edit source", mxFrontEnd);
 293
 294         SvxViewForwarder* pViewForwarder = maEditSource.GetViewForwarder();
 295
 296         if( !pViewForwarder )
 297             throw uno::RuntimeException("Unable to fetch view forwarder, model might be dead", mxFrontEnd);
 298
 299         if( !pViewForwarder->IsValid() )
 300             throw uno::RuntimeException("View forwarder is invalid, model might be dead", mxFrontEnd);
 301
 302         return *pViewForwarder;
 303     }
 304
 305     SvxEditViewForwarder& AccessibleTextHelper_Impl::GetEditViewForwarder() const
 306     {
 307         if( !maEditSource.IsValid() )
 308             throw uno::RuntimeException("Unknown edit source", mxFrontEnd);
 309
 310         SvxEditViewForwarder* pViewForwarder = maEditSource.GetEditViewForwarder();
 311
 312         if( !pViewForwarder )
 313         {
 314             throw uno::RuntimeException("No edit view forwarder, object not in edit mode", mxFrontEnd);
 315         }
 316
 317         if( !pViewForwarder->IsValid() )
 318         {
 319             throw uno::RuntimeException("View forwarder is invalid, object not in edit mode", mxFrontEnd);
 320         }
 321
 322         return *pViewForwarder;
 323     }
 324
 325     SvxEditSourceAdapter& AccessibleTextHelper_Impl::GetEditSource() const
 326     {
 327         if( !maEditSource.IsValid() )
 328             throw uno::RuntimeException("AccessibleTextHelper_Impl::GetEditSource: no edit source", mxFrontEnd );
 329         return maEditSource;
 330     }
 331
 332     // functor for sending child events (no stand-alone function, they are maybe not inlined)
 333     class AccessibleTextHelper_OffsetChildIndex
 334     {
 335     public:
 336         explicit AccessibleTextHelper_OffsetChildIndex( sal_Int32 nDifference ) : mnDifference(nDifference) {}
 337         void operator()( ::accessibility::AccessibleEditableTextPara& rPara )
 338         {
 339             rPara.SetIndexInParent( rPara.GetIndexInParent() + mnDifference );
 340         }
 341
 342     private:
 343         const sal_Int32 mnDifference;
 344     };
 345
 346     void AccessibleTextHelper_Impl::SetStartIndex( sal_Int32 nOffset )
 347     {
 348         sal_Int32 nOldOffset( mnStartIndex );
 349
 350         mnStartIndex = nOffset;
 351
 352         if( nOldOffset != nOffset )
 353         {
 354             // update children
 355             AccessibleTextHelper_OffsetChildIndex aFunctor( nOffset - nOldOffset );
 356
 357             ::std::for_each( maParaManager.begin(), maParaManager.end(),
 358                              AccessibleParaManager::WeakChildAdapter< AccessibleTextHelper_OffsetChildIndex > (aFunctor) );
 359         }
 360     }
 361
 362     void AccessibleTextHelper_Impl::SetAdditionalChildStates( const VectorOfStates& rChildStates )
 363     {
 364         maParaManager.SetAdditionalChildStates( rChildStates );
 365     }
 366
 367     void AccessibleTextHelper_Impl::SetChildFocus( sal_Int32 nChild, bool bHaveFocus )
 368     {
 369         if( bHaveFocus )
 370         {
 371             if( mbThisHasFocus )
 372                 SetShapeFocus( false );
 373
 374             maParaManager.SetFocus( nChild );
 375
 376             // we just received the focus, also send caret event then
 377             UpdateSelection();
 378
 379             SAL_INFO("svx", "Paragraph " << nChild << " received focus");
 380         }
 381         else
 382         {
 383             maParaManager.SetFocus( -1 );
 384
 385             SAL_INFO("svx", "Paragraph " << nChild << " lost focus");
 386
 387             if( mbGroupHasFocus )
 388                 SetShapeFocus( true );
 389         }
 390     }
 391
 392     void AccessibleTextHelper_Impl::ChangeChildFocus( sal_Int32 nNewChild )
 393     {
 394         if( mbThisHasFocus )
 395             SetShapeFocus( false );
 396
 397         mbGroupHasFocus = true;
 398         maParaManager.SetFocus( nNewChild );
 399
 400         SAL_INFO("svx", "Paragraph " << nNewChild << " received focus");
 401     }
 402
 403     void AccessibleTextHelper_Impl::SetShapeFocus( bool bHaveFocus )
 404     {
 405         bool bOldFocus( mbThisHasFocus );
 406
 407         mbThisHasFocus = bHaveFocus;
 408
 409         if( bOldFocus != bHaveFocus )
 410         {
 411             if( bHaveFocus )
 412             {
 413                 if( mxFrontEnd.is() )
 414                 {
 415                     AccessibleCell* pAccessibleCell = dynamic_cast< AccessibleCell* > ( mxFrontEnd.get() );
 416                     if ( !pAccessibleCell )
 417                         GotPropertyEvent( uno::makeAny(AccessibleStateType::FOCUSED), AccessibleEventId::STATE_CHANGED );
 418                     else    // the focus event on cell should be fired on table directly
 419                     {
 420                         AccessibleTableShape* pAccTable = pAccessibleCell->GetParentTable();
 421                         if (pAccTable)
 422                             pAccTable->SetStateDirectly(AccessibleStateType::FOCUSED);
 423                     }
 424                 }
 425                 SAL_INFO("svx", "Parent object received focus" );
 426             }
 427             else
 428             {
 429                 // The focus state should be reset directly on table.
 430                 //LostPropertyEvent( uno::makeAny(AccessibleStateType::FOCUSED), AccessibleEventId::STATE_CHANGED );
 431                 if( mxFrontEnd.is() )
 432                 {
 433                     AccessibleCell* pAccessibleCell = dynamic_cast< AccessibleCell* > ( mxFrontEnd.get() );
 434                     if ( !pAccessibleCell )
 435                         FireEvent( AccessibleEventId::STATE_CHANGED, uno::Any(), uno::makeAny(AccessibleStateType::FOCUSED) );
 436                     else
 437                     {
 438                         AccessibleTableShape* pAccTable = pAccessibleCell->GetParentTable();
 439                         if (pAccTable)
 440                             pAccTable->ResetStateDirectly(AccessibleStateType::FOCUSED);
 441                     }
 442                 }
 443                 SAL_INFO("svx", "Parent object lost focus" );
 444             }
 445         }
 446     }
 447
 448     void AccessibleTextHelper_Impl::SetFocus( bool bHaveFocus )
 449     {
 450         bool bOldFocus( mbGroupHasFocus );
 451
 452         mbGroupHasFocus = bHaveFocus;
 453
 454         if( IsActive() )
 455         {
 456             try
 457             {
 458                 // find the one with the cursor and get/set focus accordingly
 459                 ESelection aSelection;
 460                 if( GetEditViewForwarder().GetSelection( aSelection ) )
 461                     SetChildFocus( aSelection.nEndPara, bHaveFocus );
 462             }
 463             catch( const uno::Exception& ) {}
 464         }
 465         else if( bOldFocus != bHaveFocus )
 466         {
 467             SetShapeFocus( bHaveFocus );
 468         }
 469
 470         SAL_INFO("svx", "focus changed, Object " << this << ", state: " << (bHaveFocus ? "focused" : "not focused") );
 471     }
 472
 473     bool AccessibleTextHelper_Impl::IsActive() const
 474     {
 475         try
 476         {
 477             SvxEditSource& rEditSource = GetEditSource();
 478             SvxEditViewForwarder* pViewForwarder = rEditSource.GetEditViewForwarder();
 479
 480             if( !pViewForwarder )
 481                 return false;
 482
 483             if( mxFrontEnd.is() )
 484             {
 485                 AccessibleCell* pAccessibleCell = dynamic_cast< AccessibleCell* > ( mxFrontEnd.get() );
 486                 if ( pAccessibleCell )
 487                 {
 488                     sdr::table::CellRef xCell = pAccessibleCell->getCellRef();
 489                     if ( xCell.is() )
 490                         return xCell->IsActiveCell();
 491                 }
 492             }
 493             return pViewForwarder->IsValid();
 494         }
 495         catch( const uno::RuntimeException& )
 496         {
 497             return false;
 498         }
 499     }
 500
 501     void AccessibleTextHelper_Impl::UpdateSelection()
 502     {
 503         try
 504         {
 505             ESelection aSelection;
 506             if( GetEditViewForwarder().GetSelection( aSelection ) )
 507             {
 508                 if( maLastSelection != aSelection &&
 509                     aSelection.nEndPara < maParaManager.GetNum() )
 510                 {
 511                     // #103998# Not that important, changed from assertion to trace
 512                     if( mbThisHasFocus )
 513                     {
 514                         SAL_INFO("svx", "Parent has focus!");
 515                     }
 516
 517                     sal_Int32 nMaxValidParaIndex( GetTextForwarder().GetParagraphCount() - 1 );
 518
 519                     // notify all affected paragraphs (TODO: may be suboptimal,
 520                     // since some paragraphs might stay selected)
 521                     if( maLastSelection.nStartPara != EE_PARA_NOT_FOUND )
 522                     {
 523                         // Did the caret move from one paragraph to another?
 524                         // #100530# no caret events if not focused.
 525                         if( mbGroupHasFocus &&
 526                             maLastSelection.nEndPara != aSelection.nEndPara )
 527                         {
 528                             if( maLastSelection.nEndPara < maParaManager.GetNum() )
 529                             {
 530                                 maParaManager.FireEvent( ::std::min( maLastSelection.nEndPara, nMaxValidParaIndex ),
 531                                                          ::std::min( maLastSelection.nEndPara, nMaxValidParaIndex )+1,
 532                                                          AccessibleEventId::CARET_CHANGED,
 533                                                          uno::makeAny(static_cast<sal_Int32>(-1)),
 534                                                          uno::makeAny(maLastSelection.nEndPos) );
 535                             }
 536
 537                             ChangeChildFocus( aSelection.nEndPara );
 538
 539                             SAL_INFO(
 540                                 "svx",
 541                                 "focus changed, Object: " << this
 542                                     << ", Paragraph: " << aSelection.nEndPara
 543                                     << ", Last paragraph: "
 544                                     << maLastSelection.nEndPara);
 545                         }
 546                     }
 547
 548                     // #100530# no caret events if not focused.
 549                     if( mbGroupHasFocus )
 550                     {
 551                         uno::Any aOldCursor;
 552
 553                         // #i13705# The old cursor can only contain valid
 554                         // values if it's the same paragraph!
 555                         if( maLastSelection.nStartPara != EE_PARA_NOT_FOUND &&
 556                             maLastSelection.nEndPara == aSelection.nEndPara )
 557                         {
 558                             aOldCursor <<= maLastSelection.nEndPos;
 559                         }
 560                         else
 561                         {
 562                             aOldCursor <<= static_cast<sal_Int32>(-1);
 563                         }
 564
 565                         maParaManager.FireEvent( aSelection.nEndPara,
 566                                                  aSelection.nEndPara+1,
 567                                                  AccessibleEventId::CARET_CHANGED,
 568                                                  uno::makeAny(aSelection.nEndPos),
 569                                                  aOldCursor );
 570                     }
 571
 572                     SAL_INFO(
 573                         "svx",
 574                         "caret changed, Object: " << this << ", New pos: "
 575                             << aSelection.nEndPos << ", Old pos: "
 576                             << maLastSelection.nEndPos << ", New para: "
 577                             << aSelection.nEndPara << ", Old para: "
 578                             << maLastSelection.nEndPara);
 579
 580                     // #108947# Sort new range before calling FireEvent
 581                     ::std::pair<sal_Int32, sal_Int32> sortedSelection(
 582                         makeSortedPair(::std::min( aSelection.nStartPara, nMaxValidParaIndex ),
 583                                        ::std::min( aSelection.nEndPara, nMaxValidParaIndex ) ) );
 584
 585                     // #108947# Sort last range before calling FireEvent
 586                     ::std::pair<sal_Int32, sal_Int32> sortedLastSelection(
 587                         makeSortedPair(::std::min( maLastSelection.nStartPara, nMaxValidParaIndex ),
 588                                        ::std::min( maLastSelection.nEndPara, nMaxValidParaIndex ) ) );
 589
 590                     // event TEXT_SELECTION_CHANGED has to be submitted. (#i27299#)
 591                     const sal_Int16 nTextSelChgEventId =
 592                                     AccessibleEventId::TEXT_SELECTION_CHANGED;
 593                     // #107037# notify selection change
 594                     if( maLastSelection.nStartPara == EE_PARA_NOT_FOUND )
 595                     {
 596                         // last selection is undefined
 597                         // use method <ESelection::HasRange()> (#i27299#)
 598                         if ( aSelection.HasRange() )
 599                         {
 600                             // selection was undefined, now is on
 601                             maParaManager.FireEvent( sortedSelection.first,
 602                                                      sortedSelection.second+1,
 603                                                      nTextSelChgEventId );
 604                         }
 605                     }
 606                     else
 607                     {
 608                         // last selection is valid
 609                         // use method <ESelection::HasRange()> (#i27299#)
 610                         if ( maLastSelection.HasRange() &&
 611                              !aSelection.HasRange() )
 612                         {
 613                             // selection was on, now is empty
 614                             maParaManager.FireEvent( sortedLastSelection.first,
 615                                                      sortedLastSelection.second+1,
 616                                                      nTextSelChgEventId );
 617                         }
 618                         // use method <ESelection::HasRange()> (#i27299#)
 619                         else if( !maLastSelection.HasRange() &&
 620                                  aSelection.HasRange() )
 621                         {
 622                             // selection was empty, now is on
 623                             maParaManager.FireEvent( sortedSelection.first,
 624                                                      sortedSelection.second+1,
 625                                                      nTextSelChgEventId );
 626                         }
 627                         // no event TEXT_SELECTION_CHANGED event, if new and
 628                         // last selection are empty. (#i27299#)
 629                         else if ( maLastSelection.HasRange() &&
 630                                   aSelection.HasRange() )
 631                         {
 632                             // use sorted last and new selection
 633                             ESelection aTmpLastSel( maLastSelection );
 634                             aTmpLastSel.Adjust();
 635                             ESelection aTmpSel( aSelection );
 636                             aTmpSel.Adjust();
 637                             // first submit event for new and changed selection
 638                             sal_Int32 nPara = aTmpSel.nStartPara;
 639                             for ( ; nPara <= aTmpSel.nEndPara; ++nPara )
 640                             {
 641                                 if ( nPara < aTmpLastSel.nStartPara ||
 642                                      nPara > aTmpLastSel.nEndPara )
 643                                 {
 644                                     // new selection on paragraph <nPara>
 645                                     maParaManager.FireEvent( nPara,
 646                                                              nTextSelChgEventId );
 647                                 }
 648                                 else
 649                                 {
 650                                     // check for changed selection on paragraph <nPara>
 651                                     const sal_Int32 nParaStartPos =
 652                                             nPara == aTmpSel.nStartPara
 653                                             ? aTmpSel.nStartPos : 0;
 654                                     const sal_Int32 nParaEndPos =
 655                                             nPara == aTmpSel.nEndPara
 656                                             ? aTmpSel.nEndPos : -1;
 657                                     const sal_Int32 nLastParaStartPos =
 658                                             nPara == aTmpLastSel.nStartPara
 659                                             ? aTmpLastSel.nStartPos : 0;
 660                                     const sal_Int32 nLastParaEndPos =
 661                                             nPara == aTmpLastSel.nEndPara
 662                                             ? aTmpLastSel.nEndPos : -1;
 663                                     if ( nParaStartPos != nLastParaStartPos ||
 664                                          nParaEndPos != nLastParaEndPos )
 665                                     {
 666                                         maParaManager.FireEvent(
 667                                                     nPara, nTextSelChgEventId );
 668                                     }
 669                                 }
 670                             }
 671                             // second submit event for 'old' selections
 672                             nPara = aTmpLastSel.nStartPara;
 673                             for ( ; nPara <= aTmpLastSel.nEndPara; ++nPara )
 674                             {
 675                                 if ( nPara < aTmpSel.nStartPara ||
 676                                      nPara > aTmpSel.nEndPara )
 677                                 {
 678                                     maParaManager.FireEvent( nPara,
 679                                                              nTextSelChgEventId );
 680                                 }
 681                             }
 682                         }
 683                     }
 684
 685                     maLastSelection = aSelection;
 686                 }
 687             }
 688         }
 689         // no selection? no update actions
 690         catch( const uno::RuntimeException& ) {}
 691     }
 692
 693     void AccessibleTextHelper_Impl::ShutdownEditSource()
 694     {
 695         // This should only be called with solar mutex locked, i.e. from the main office thread
 696
 697         // This here is somewhat clumsy: As soon as our children have
 698         // a NULL EditSource (maParaManager.SetEditSource()), they
 699         // enter the disposed state and cannot be reanimated. Thus, it
 700         // is unavoidable and a hard requirement to let go and create
 701         // from scratch each and every child.
 702
 703         // invalidate children
 704         maParaManager.Dispose();
 705         maParaManager.SetNum(0);
 706
 707         // lost all children
 708         if( mxFrontEnd.is() )
 709             FireEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN);
 710
 711         // quit listen on stale edit source
 712         if( maEditSource.IsValid() )
 713             EndListening( maEditSource.GetBroadcaster() );
 714
 715         maEditSource.SetEditSource( ::std::unique_ptr< SvxEditSource >() );
 716     }
 717
 718     void AccessibleTextHelper_Impl::SetEditSource( ::std::unique_ptr< SvxEditSource > && pEditSource )
 719     {
 720         // This should only be called with solar mutex locked, i.e. from the main office thread
 721
 722         // shutdown old edit source
 723         ShutdownEditSource();
 724
 725         // set new edit source
 726         maEditSource.SetEditSource( std::move(pEditSource) );
 727
 728         // init child vector to the current child count
 729         if( maEditSource.IsValid() )
 730         {
 731             maParaManager.SetNum( GetTextForwarder().GetParagraphCount() );
 732
 733             // listen on new edit source
 734             StartListening( maEditSource.GetBroadcaster() );
 735
 736             UpdateVisibleChildren();
 737         }
 738     }
 739
 740     void AccessibleTextHelper_Impl::SetOffset( const Point& rPoint )
 741     {
 742         // guard against non-atomic access to maOffset data structure
 743         {
 744             ::osl::MutexGuard aGuard( maMutex );
 745             maOffset = rPoint;
 746         }
 747
 748         maParaManager.SetEEOffset( rPoint );
 749
 750         // in all cases, check visibility afterwards.
 751         UpdateVisibleChildren();
 752         UpdateBoundRect();
 753     }
 754
 755     void AccessibleTextHelper_Impl::UpdateVisibleChildren( bool bBroadcastEvents )
 756     {
 757         try
 758         {
 759             SvxTextForwarder& rCacheTF = GetTextForwarder();
 760             sal_Int32 nParas=rCacheTF.GetParagraphCount();
 761
 762             mnFirstVisibleChild = -1;
 763             mnLastVisibleChild = -2;
 764
 765             for( sal_Int32 nCurrPara=0; nCurrPara<nParas; ++nCurrPara )
 766             {
 767                 if (nCurrPara == 0)
 768                     mnFirstVisibleChild = nCurrPara;
 769                 mnLastVisibleChild = nCurrPara;
 770                 if (mxFrontEnd.is() && bBroadcastEvents)
 771                 {
 772                     // child not yet created?
 773                     ::accessibility::AccessibleParaManager::WeakChild aChild( maParaManager.GetChild(nCurrPara) );
 774                     if( aChild.second.Width == 0 &&
 775                         aChild.second.Height == 0 )
 776                     {
 777                         GotPropertyEvent( uno::makeAny( maParaManager.CreateChild( nCurrPara - mnFirstVisibleChild,
 778                                                                                    mxFrontEnd, GetEditSource(), nCurrPara ).first ),
 779                                           AccessibleEventId::CHILD );
 780                     }
 781                 }
 782             }
 783         }
 784         catch( const uno::Exception& )
 785         {
 786             OSL_FAIL("AccessibleTextHelper_Impl::UpdateVisibleChildren error while determining visible children");
 787
 788             // something failed - currently no children
 789             mnFirstVisibleChild = -1;
 790             mnLastVisibleChild = -2;
 791             maParaManager.SetNum(0);
 792
 793             // lost all children
 794             if( bBroadcastEvents )
 795                 FireEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN);
 796         }
 797     }
 798
 799     // functor for checking changes in paragraph bounding boxes (no stand-alone function, maybe not inlined)
 800     class AccessibleTextHelper_UpdateChildBounds
 801     {
 802     public:
 803         explicit AccessibleTextHelper_UpdateChildBounds() {}
 804         ::accessibility::AccessibleParaManager::WeakChild operator()( const ::accessibility::AccessibleParaManager::WeakChild& rChild )
 805         {
 806             // retrieve hard reference from weak one
 807             auto aHardRef( rChild.first.get() );
 808
 809             if( aHardRef.is() )
 810             {
 811                 awt::Rectangle          aNewRect = aHardRef->getBounds();
 812                 const awt::Rectangle&   aOldRect = rChild.second;
 813
 814                 if( aNewRect.X != aOldRect.X ||
 815                     aNewRect.Y != aOldRect.Y ||
 816                     aNewRect.Width != aOldRect.Width ||
 817                     aNewRect.Height != aOldRect.Height )
 818                 {
 819                     // visible data changed
 820                     aHardRef->FireEvent( AccessibleEventId::BOUNDRECT_CHANGED );
 821
 822                     // update internal bounds
 823                     return ::accessibility::AccessibleParaManager::WeakChild( rChild.first, aNewRect );
 824                 }
 825             }
 826
 827             // identity transform
 828             return rChild;
 829         }
 830     };
 831
 832     void AccessibleTextHelper_Impl::UpdateBoundRect()
 833     {
 834         // send BOUNDRECT_CHANGED to affected children
 835         AccessibleTextHelper_UpdateChildBounds aFunctor;
 836         ::std::transform( maParaManager.begin(), maParaManager.end(), maParaManager.begin(), aFunctor );
 837     }
 838
 839 #ifdef DBG_UTIL
 840     void AccessibleTextHelper_Impl::CheckInvariants() const
 841     {
 842         if( mnFirstVisibleChild >= 0 &&
 843             mnFirstVisibleChild > mnLastVisibleChild )
 844         {
 845             OSL_FAIL( "AccessibleTextHelper: range invalid" );
 846         }
 847     }
 848 #endif
 849
 850     // functor for sending child events (no stand-alone function, they are maybe not inlined)
 851     class AccessibleTextHelper_LostChildEvent
 852     {
 853     public:
 854         explicit AccessibleTextHelper_LostChildEvent( AccessibleTextHelper_Impl& rImpl ) : mrImpl(rImpl) {}
 855         void operator()( const ::accessibility::AccessibleParaManager::WeakChild& rPara )
 856         {
 857             // retrieve hard reference from weak one
 858             auto aHardRef( rPara.first.get() );
 859
 860             if( aHardRef.is() )
 861                 mrImpl.FireEvent(AccessibleEventId::CHILD, uno::Any(), uno::makeAny<css::uno::Reference<css::accessibility::XAccessible>>(aHardRef.get()) );
 862         }
 863
 864     private:
 865         AccessibleTextHelper_Impl&  mrImpl;
 866     };
 867
 868     void AccessibleTextHelper_Impl::ParagraphsMoved( sal_Int32 nFirst, sal_Int32 nMiddle, sal_Int32 nLast )
 869     {
 870         const sal_Int32 nParas = GetTextForwarder().GetParagraphCount();
 871
 872         /* rotate paragraphs
 873          * =================
 874          *
 875          * Three cases:
 876          *
 877          * 1.
 878          *   ... nParagraph ... nParam1 ... nParam2 ...
 879          *       |______________[xxxxxxxxxxx]
 880          *              becomes
 881          *       [xxxxxxxxxxx]|______________
 882          *
 883          * tail is 0
 884          *
 885          * 2.
 886          *   ... nParam1 ... nParagraph ... nParam2 ...
 887          *       [xxxxxxxxxxx|xxxxxxxxxxxxxx]____________
 888          *              becomes
 889          *       ____________[xxxxxxxxxxx|xxxxxxxxxxxxxx]
 890          *
 891          * tail is nParagraph - nParam1
 892          *
 893          * 3.
 894          *   ... nParam1 ... nParam2 ... nParagraph ...
 895          *       [xxxxxxxxxxx]___________|____________
 896          *              becomes
 897          *       ___________|____________[xxxxxxxxxxx]
 898          *
 899          * tail is nParam2 - nParam1
 900          */
 901
 902         // sort nParagraph, nParam1 and nParam2 in ascending order, calc range
 903         if( nMiddle < nFirst )
 904         {
 905             ::std::swap(nFirst, nMiddle);
 906         }
 907         else if( nMiddle < nLast )
 908         {
 909             nLast = nLast + nMiddle - nFirst;
 910         }
 911         else
 912         {
 913             ::std::swap(nMiddle, nLast);
 914             nLast = nLast + nMiddle - nFirst;
 915         }
 916
 917         if( nFirst < nParas && nMiddle < nParas && nLast < nParas )
 918         {
 919             // since we have no "paragraph index
 920             // changed" event on UAA, remove
 921             // [first,last] and insert again later (in
 922             // UpdateVisibleChildren)
 923
 924             // maParaManager.Rotate( nFirst, nMiddle, nLast );
 925
 926             // send CHILD_EVENT to affected children
 927             ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin();
 928             ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin;
 929
 930             ::std::advance( begin, nFirst );
 931             ::std::advance( end, nLast+1 );
 932
 933             // TODO: maybe optimize here in the following way.  If the
 934             // number of removed children exceeds a certain threshold,
 935             // use InvalidateFlags::Children
 936             AccessibleTextHelper_LostChildEvent aFunctor( *this );
 937
 938             ::std::for_each( begin, end, aFunctor );
 939
 940             maParaManager.Release(nFirst, nLast+1);
 941             // should be no need for UpdateBoundRect, since all affected children are cleared.
 942         }
 943     }
 944
 945     // functor for sending child events (no stand-alone function, they are maybe not inlined)
 946     class AccessibleTextHelper_ChildrenTextChanged
 947     {
 948     public:
 949         void operator()( ::accessibility::AccessibleEditableTextPara& rPara )
 950         {
 951             rPara.TextChanged();
 952         }
 953     };
 954
 955     /** functor processing queue events
 956
 957         Reacts on SfxHintId::TextParaInserted/REMOVED events and stores
 958         their content
 959      */
 960     class AccessibleTextHelper_QueueFunctor
 961     {
 962     public:
 963         AccessibleTextHelper_QueueFunctor() :
 964             mnParasChanged( 0 ),
 965             mnParaIndex(-1),
 966             mnHintId(SfxHintId::NONE)
 967         {}
 968         void operator()( const SfxHint* pEvent )
 969         {
 970             if( pEvent &&
 971                 mnParasChanged != -1 )
 972             {
 973                 // determine hint type
 974                 const TextHint* pTextHint = dynamic_cast<const TextHint*>( pEvent );
 975                 const SvxEditSourceHint* pEditSourceHint = dynamic_cast<const SvxEditSourceHint*>( pEvent );
 976
 977                 if( !pEditSourceHint && pTextHint &&
 978                     (pTextHint->GetId() == SfxHintId::TextParaInserted ||
 979                      pTextHint->GetId() == SfxHintId::TextParaRemoved ) )
 980                 {
 981                     if( pTextHint->GetValue() == EE_PARA_ALL )
 982                     {
 983                         mnParasChanged = -1;
 984                     }
 985                     else
 986                     {
 987                         mnHintId = pTextHint->GetId();
 988                         mnParaIndex = pTextHint->GetValue();
 989                         ++mnParasChanged;
 990                     }
 991                 }
 992             }
 993         }
 994
 995         /** Query number of paragraphs changed during queue processing.
 996
 997             @return number of changed paragraphs, -1 for
 998             "every paragraph changed"
 999         */
1000         sal_Int32 GetNumberOfParasChanged() const { return mnParasChanged; }
1001         /** Query index of last added/removed paragraph
1002
1003             @return index of lastly added paragraphs, -1 for none
1004             added so far.
1005         */
1006         sal_Int32 GetParaIndex() const { return mnParaIndex; }
1007         /** Query hint id of last interesting event
1008
1009             @return hint id of last interesting event (REMOVED/INSERTED).
1010         */
1011         SfxHintId GetHintId() const { return mnHintId; }
1012
1013     private:
1014         /** number of paragraphs changed during queue processing. -1 for
1015             "every paragraph changed"
1016         */
1017         sal_Int32 mnParasChanged;
1018         /// index of paragraph added/removed last
1019         sal_Int32 mnParaIndex;
1020         /// TextHint ID (removed/inserted) of last interesting event
1021         SfxHintId mnHintId;
1022     };
1023
1024     void AccessibleTextHelper_Impl::ProcessQueue()
1025     {
1026         // inspect queue for paragraph insert/remove events. If there
1027         // is exactly _one_ of those in the queue, and the number of
1028         // paragraphs has changed by exactly one, use that event to
1029         // determine a priori which paragraph was added/removed. This
1030         // is necessary, since I must sync right here with the
1031         // EditEngine state (number of paragraphs etc.), since I'm
1032         // potentially sending listener events right away.
1033         AccessibleTextHelper_QueueFunctor aFunctor;
1034         maEventQueue.ForEach( aFunctor );
1035
1036         const sal_Int32 nNewParas( GetTextForwarder().GetParagraphCount() );
1037         const sal_Int32 nCurrParas( maParaManager.GetNum() );
1038
1039         // whether every paragraph already is updated (no need to
1040         // repeat that later on, e.g. for PARA_MOVED events)
1041         bool            bEverythingUpdated( false );
1042
1043         if( labs( nNewParas - nCurrParas ) == 1 &&
1044             aFunctor.GetNumberOfParasChanged() == 1 )
1045         {
1046             // #103483# Exactly one paragraph added/removed. This is
1047             // the normal case, optimize event handling here.
1048
1049             if( aFunctor.GetHintId() == SfxHintId::TextParaInserted )
1050             {
1051                 // update num of paras
1052                 maParaManager.SetNum( nNewParas );
1053
1054                 // release everything from the insertion position until the end
1055                 maParaManager.Release(aFunctor.GetParaIndex(), nCurrParas);
1056
1057                 // TODO: Clarify whether this behaviour _really_ saves
1058                 // anybody anything!
1059                 // update children, _don't_ broadcast
1060                 UpdateVisibleChildren( false );
1061                 UpdateBoundRect();
1062
1063                 // send insert event
1064                 // #109864# Enforce creation of this paragraph
1065                 try
1066                 {
1067                     GotPropertyEvent( uno::makeAny( getAccessibleChild( aFunctor.GetParaIndex() -
1068                                                                         mnFirstVisibleChild + GetStartIndex() ) ),
1069                                       AccessibleEventId::CHILD );
1070                 }
1071                 catch( const uno::Exception& )
1072                 {
1073                     OSL_FAIL("AccessibleTextHelper_Impl::ProcessQueue: could not create new paragraph");
1074                 }
1075             }
1076             else if( aFunctor.GetHintId() == SfxHintId::TextParaRemoved )
1077             {
1078                 ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin();
1079                 ::std::advance( begin, aFunctor.GetParaIndex() );
1080                 ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin;
1081                 ::std::advance( end, 1 );
1082
1083                 // #i61812# remember para to be removed for later notification
1084                 // AFTER the new state is applied (that after the para got removed)
1085                 ::uno::Reference< XAccessible > xPara(begin->first.get().get());
1086
1087                 // release everything from the remove position until the end
1088                 maParaManager.Release(aFunctor.GetParaIndex(), nCurrParas);
1089
1090                 // update num of paras
1091                 maParaManager.SetNum( nNewParas );
1092
1093                 // TODO: Clarify whether this behaviour _really_ saves
1094                 // anybody anything!
1095                 // update children, _don't_ broadcast
1096                 UpdateVisibleChildren( false );
1097                 UpdateBoundRect();
1098
1099                 // #i61812# notification for removed para
1100                 if (xPara.is())
1101                     FireEvent(AccessibleEventId::CHILD, uno::Any(), uno::makeAny( xPara) );
1102             }
1103 #ifdef DBG_UTIL
1104             else
1105                 OSL_FAIL("AccessibleTextHelper_Impl::ProcessQueue() invalid hint id");
1106 #endif
1107         }
1108         else if( nNewParas != nCurrParas )
1109         {
1110             // release all paras
1111             maParaManager.Release(0, nCurrParas);
1112
1113             // update num of paras
1114             maParaManager.SetNum( nNewParas );
1115
1116             // #109864# create from scratch, don't broadcast
1117             UpdateVisibleChildren( false );
1118             UpdateBoundRect();
1119
1120             // number of paragraphs somehow changed - but we have no
1121             // chance determining how. Thus, throw away everything and
1122             // create from scratch.
1123             // (child events should be broadcast after the changes are done...)
1124             FireEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN);
1125
1126             // no need for further updates later on
1127             bEverythingUpdated = true;
1128         }
1129
1130         while( !maEventQueue.IsEmpty() )
1131         {
1132             ::std::unique_ptr< SfxHint > pHint( maEventQueue.PopFront() );
1133             if (pHint)
1134             {
1135                 const SfxHint& rHint = *pHint;
1136
1137                 // Note, if you add events here, you need to update the AccessibleTextEventQueue::Append
1138                 // code, because only the events we process here, are actually queued there.
1139
1140                 try
1141                 {
1142
1143                     if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
1144                     {
1145                         const SdrHint* pSdrHint = static_cast< const SdrHint* >( &rHint );
1146
1147                         switch( pSdrHint->GetKind() )
1148                         {
1149                             case SdrHintKind::BeginEdit:
1150                             {
1151                                 if(!IsActive())
1152                                 {
1153                                     break;
1154                                 }
1155                                 // change children state
1156                                 maParaManager.SetActive();
1157
1158                                 // per definition, edit mode text has the focus
1159                                 SetFocus( true );
1160                                 break;
1161                             }
1162
1163                             case SdrHintKind::EndEdit:
1164                             {
1165                                 // focused child now loses focus
1166                                 ESelection aSelection;
1167                                 if( GetEditViewForwarder().GetSelection( aSelection ) )
1168                                     SetChildFocus( aSelection.nEndPara, false );
1169
1170                                 // change children state
1171                                 maParaManager.SetActive( false );
1172
1173                                 maLastSelection = ESelection( EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND,
1174                                                               EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
1175                                 break;
1176                             }
1177                             default:
1178                                 break;
1179                         }
1180                     }
1181                     else if( const SvxEditSourceHint* pEditSourceHint = dynamic_cast<const SvxEditSourceHint*>( &rHint ) )
1182                     {
1183                         switch( pEditSourceHint->GetId() )
1184                         {
1185                             case SfxHintId::EditSourceParasMoved:
1186                             {
1187                                 DBG_ASSERT( pEditSourceHint->GetStartValue() < GetTextForwarder().GetParagraphCount() &&
1188                                             pEditSourceHint->GetEndValue() < GetTextForwarder().GetParagraphCount(),
1189                                             "AccessibleTextHelper_Impl::NotifyHdl: Invalid notification");
1190
1191                                 if( !bEverythingUpdated )
1192                                 {
1193                                     ParagraphsMoved(pEditSourceHint->GetStartValue(),
1194                                                     pEditSourceHint->GetValue(),
1195                                                     pEditSourceHint->GetEndValue());
1196
1197                                     // in all cases, check visibility afterwards.
1198                                     UpdateVisibleChildren();
1199                                 }
1200                                 break;
1201                             }
1202
1203                             case SfxHintId::EditSourceSelectionChanged:
1204                                 // notify listeners
1205                                 try
1206                                 {
1207                                     UpdateSelection();
1208                                 }
1209                                 // maybe we're not in edit mode (this is not an error)
1210                                 catch( const uno::Exception& ) {}
1211                                 break;
1212                             default: break;
1213                         }
1214                     }
1215                     else if( const TextHint* pTextHint = dynamic_cast<const TextHint*>( &rHint ) )
1216                     {
1217                         const sal_Int32 nParas = GetTextForwarder().GetParagraphCount();
1218
1219                         switch( pTextHint->GetId() )
1220                         {
1221                             case SfxHintId::TextModified:
1222                             {
1223                                 // notify listeners
1224                                 sal_Int32 nPara( pTextHint->GetValue() );
1225
1226                                 // #108900# Delegate change event to children
1227                                 AccessibleTextHelper_ChildrenTextChanged aNotifyChildrenFunctor;
1228
1229                                 if( nPara == EE_PARA_ALL )
1230                                 {
1231                                     // #108900# Call every child
1232                                     ::std::for_each( maParaManager.begin(), maParaManager.end(),
1233                                                      AccessibleParaManager::WeakChildAdapter< AccessibleTextHelper_ChildrenTextChanged > (aNotifyChildrenFunctor) );
1234                                 }
1235                                 else
1236                                     if( nPara < nParas )
1237                                     {
1238                                         // #108900# Call child at index nPara
1239                                         ::std::for_each( maParaManager.begin()+nPara, maParaManager.begin()+nPara+1,
1240                                                          AccessibleParaManager::WeakChildAdapter< AccessibleTextHelper_ChildrenTextChanged > (aNotifyChildrenFunctor) );
1241                                     }
1242                                 break;
1243                             }
1244
1245                             case SfxHintId::TextParaInserted:
1246                                 // already happened above
1247                                 break;
1248
1249                             case SfxHintId::TextParaRemoved:
1250                                 // already happened above
1251                                 break;
1252
1253                             case SfxHintId::TextHeightChanged:
1254                                 // visibility changed, done below
1255                                 break;
1256
1257                             case SfxHintId::TextViewScrolled:
1258                                 // visibility changed, done below
1259                                 break;
1260                             default: break;
1261                         }
1262
1263                         // in all cases, check visibility afterwards.
1264                         UpdateVisibleChildren();
1265                         UpdateBoundRect();
1266                     }
1267                     else if ( dynamic_cast<const SvxViewChangedHint*>( &rHint ) )
1268                     {
1269                         // just check visibility
1270                         UpdateVisibleChildren();
1271                         UpdateBoundRect();
1272                     }
1273                     // it's VITAL to keep the SfxSimpleHint last! It's the base of some classes above!
1274                     else if( rHint.GetId() == SfxHintId::Dying)
1275                     {
1276                         // edit source is dying under us, become defunc then
1277                         try
1278                         {
1279                             // make edit source inaccessible
1280                             // Note: cannot destroy it here, since we're called from there!
1281                             ShutdownEditSource();
1282                         }
1283                         catch( const uno::Exception& ) {}
1284                     }
1285                 }
1286                 catch( const uno::Exception& )
1287                 {
1288                     DBG_UNHANDLED_EXCEPTION("svx");
1289                 }
1290             }
1291         }
1292     }
1293
1294     void AccessibleTextHelper_Impl::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1295     {
1296         // precondition: solar mutex locked
1297         DBG_TESTSOLARMUTEX();
1298
1299         // precondition: not in a recursion
1300         if( mbInNotify )
1301             return;
1302
1303         mbInNotify = true;
1304
1305         try
1306         {
1307             // Process notification event, arranged in order of likelihood of
1308             // occurrence to avoid unnecessary dynamic_cast. Note that
1309             // SvxEditSourceHint is derived from TextHint, so has to be checked
1310             // before that.
1311             if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
1312             {
1313                 const SdrHint* pSdrHint = static_cast< const SdrHint* >( &rHint );
1314                 // process drawing layer events right away, if not
1315                 // within an open EE notification frame. Otherwise,
1316                 // event processing would be delayed until next EE
1317                 // notification sequence.
1318                 maEventQueue.Append( *pSdrHint );
1319             }
1320             else if( const SvxViewChangedHint* pViewHint = dynamic_cast<const SvxViewChangedHint*>( &rHint ) )
1321             {
1322                 // process visibility right away, if not within an
1323                 // open EE notification frame. Otherwise, event
1324                 // processing would be delayed until next EE
1325                 // notification sequence.
1326                 maEventQueue.Append( *pViewHint );
1327             }
1328             else if( const SvxEditSourceHint* pEditSourceHint = dynamic_cast<const SvxEditSourceHint*>( &rHint ) )
1329             {
1330                 // EditEngine should emit TEXT_SELECTION_CHANGED events (#i27299#)
1331                 maEventQueue.Append( *pEditSourceHint );
1332             }
1333             else if( const TextHint* pTextHint = dynamic_cast<const TextHint*>( &rHint ) )
1334             {
1335                 // EditEngine should emit TEXT_SELECTION_CHANGED events (#i27299#)
1336                 if(pTextHint->GetId() == SfxHintId::TextProcessNotifications)
1337                     ProcessQueue();
1338                 else
1339                     maEventQueue.Append( *pTextHint );
1340             }
1341             // it's VITAL to keep the SfxHint last! It's the base of the classes above!
1342             else if( rHint.GetId() == SfxHintId::Dying )
1343             {
1344                 // handle this event _at once_, because after that, objects are invalid
1345                 // edit source is dying under us, become defunc then
1346                 maEventQueue.Clear();
1347                 try
1348                 {
1349                     // make edit source inaccessible
1350                     // Note: cannot destroy it here, since we're called from there!
1351                     ShutdownEditSource();
1352                 }
1353                 catch( const uno::Exception& ) {}
1354             }
1355         }
1356         catch( const uno::Exception& )
1357         {
1358             DBG_UNHANDLED_EXCEPTION("svx");
1359             mbInNotify = false;
1360         }
1361
1362         mbInNotify = false;
1363     }
1364
1365     void AccessibleTextHelper_Impl::Dispose()
1366     {
1367         if( getNotifierClientId() != -1 )
1368         {
1369             try
1370             {
1371                 // #106234# Unregister from EventNotifier
1372                 ::comphelper::AccessibleEventNotifier::revokeClient( getNotifierClientId() );
1373                 SAL_INFO("svx", "disposed ID: " << mnNotifierClientId );
1374             }
1375             catch( const uno::Exception& ) {}
1376
1377             mnNotifierClientId = -1;
1378         }
1379
1380         try
1381         {
1382             // dispose children
1383             maParaManager.Dispose();
1384         }
1385         catch( const uno::Exception& ) {}
1386
1387         // quit listen on stale edit source
1388         if( maEditSource.IsValid() )
1389             EndListening( maEditSource.GetBroadcaster() );
1390
1391         // clear references
1392         maEditSource.SetEditSource( ::std::unique_ptr< SvxEditSource >() );
1393         mxFrontEnd = nullptr;
1394     }
1395
1396     void AccessibleTextHelper_Impl::FireEvent( const sal_Int16 nEventId, const uno::Any& rNewValue, const uno::Any& rOldValue ) const
1397     {
1398         // -- object locked --
1399         AccessibleEventObject aEvent;
1400         {
1401             osl::MutexGuard aGuard(maMutex);
1402
1403             DBG_ASSERT(mxFrontEnd.is(), "AccessibleTextHelper::FireEvent: no event source set");
1404
1405             if (mxFrontEnd.is())
1406                 aEvent = AccessibleEventObject(mxFrontEnd->getAccessibleContext(), nEventId,
1407                                                rNewValue, rOldValue);
1408             else
1409                 aEvent = AccessibleEventObject(uno::Reference<uno::XInterface>(), nEventId,
1410                                                rNewValue, rOldValue);
1411
1412             // no locking necessary, FireEvent internally copies listeners
1413             // if someone removes/adds in between Further locking,
1414             // actually, might lead to deadlocks, since we're calling out
1415             // of this object
1416         }
1417         // -- until here --
1418
1419         FireEvent(aEvent);
1420     }
1421
1422     void AccessibleTextHelper_Impl::FireEvent( const AccessibleEventObject& rEvent ) const
1423     {
1424         // #102261# Call global queue for focus events
1425         if( rEvent.EventId == AccessibleStateType::FOCUSED )
1426             vcl::unohelper::NotifyAccessibleStateEventGlobally( rEvent );
1427
1428         // #106234# Delegate to EventNotifier
1429         ::comphelper::AccessibleEventNotifier::addEvent( getNotifierClientId(),
1430                                                          rEvent );
1431     }
1432
1433     // XAccessibleContext
1434     sal_Int32 AccessibleTextHelper_Impl::getAccessibleChildCount() const
1435     {
1436         return mnLastVisibleChild - mnFirstVisibleChild + 1;
1437     }
1438
1439     uno::Reference< XAccessible > AccessibleTextHelper_Impl::getAccessibleChild( sal_Int32 i )
1440     {
1441         i -= GetStartIndex();
1442
1443         if( 0 > i || i >= getAccessibleChildCount() ||
1444             GetTextForwarder().GetParagraphCount() <= i )
1445         {
1446             throw lang::IndexOutOfBoundsException("Invalid child index", mxFrontEnd);
1447         }
1448
1449         DBG_ASSERT(mxFrontEnd.is(), "AccessibleTextHelper_Impl::UpdateVisibleChildren: no frontend set");
1450
1451         if( mxFrontEnd.is() )
1452             return maParaManager.CreateChild( i, mxFrontEnd, GetEditSource(), mnFirstVisibleChild + i ).first;
1453         else
1454             return nullptr;
1455     }
1456
1457     void AccessibleTextHelper_Impl::addAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
1458     {
1459         if( getNotifierClientId() != -1 )
1460             ::comphelper::AccessibleEventNotifier::addEventListener( getNotifierClientId(), xListener );
1461     }
1462
1463     void AccessibleTextHelper_Impl::removeAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
1464     {
1465         if( getNotifierClientId() != -1 )
1466         {
1467             const sal_Int32 nListenerCount = ::comphelper::AccessibleEventNotifier::removeEventListener( getNotifierClientId(), xListener );
1468             if ( !nListenerCount )
1469             {
1470                 // no listeners anymore
1471                 // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
1472                 // and at least to us not firing any events anymore, in case somebody calls
1473                 // NotifyAccessibleEvent, again
1474                 ::comphelper::AccessibleEventNotifier::TClientId nId( getNotifierClientId() );
1475                 mnNotifierClientId = -1;
1476                 ::comphelper::AccessibleEventNotifier::revokeClient( nId );
1477             }
1478         }
1479     }
1480
1481     uno::Reference< XAccessible > AccessibleTextHelper_Impl::getAccessibleAtPoint( const awt::Point& _aPoint )
1482     {
1483         // make given position relative
1484         if( !mxFrontEnd.is() )
1485             throw uno::RuntimeException("AccessibleTextHelper_Impl::getAccessibleAt: frontend invalid", mxFrontEnd );
1486
1487         uno::Reference< XAccessibleContext > xFrontEndContext = mxFrontEnd->getAccessibleContext();
1488
1489         if( !xFrontEndContext.is() )
1490             throw uno::RuntimeException("AccessibleTextHelper_Impl::getAccessibleAt: frontend invalid", mxFrontEnd );
1491
1492         uno::Reference< XAccessibleComponent > xFrontEndComponent( xFrontEndContext, uno::UNO_QUERY_THROW );
1493
1494         // #103862# No longer need to make given position relative
1495         Point aPoint( _aPoint.X, _aPoint.Y );
1496
1497         // respect EditEngine offset to surrounding shape/cell
1498         aPoint -= GetOffset();
1499
1500         // convert to EditEngine coordinate system
1501         SvxTextForwarder& rCacheTF = GetTextForwarder();
1502         Point aLogPoint( GetViewForwarder().PixelToLogic( aPoint, rCacheTF.GetMapMode() ) );
1503
1504         // iterate over all visible children (including those not yet created)
1505         sal_Int32 nChild;
1506         for( nChild=mnFirstVisibleChild; nChild <= mnLastVisibleChild; ++nChild )
1507         {
1508             DBG_ASSERT(nChild >= 0,
1509                        "AccessibleTextHelper_Impl::getAccessibleAt: index value overflow");
1510
1511             tools::Rectangle aParaBounds( rCacheTF.GetParaBounds( nChild ) );
1512
1513             if( aParaBounds.IsInside( aLogPoint ) )
1514                 return getAccessibleChild( nChild - mnFirstVisibleChild + GetStartIndex() );
1515         }
1516
1517         // found none
1518         return nullptr;
1519     }
1520
1521
1522     // AccessibleTextHelper implementation (simply forwards to impl)
1523
1524     AccessibleTextHelper::AccessibleTextHelper( ::std::unique_ptr< SvxEditSource > && pEditSource ) :
1525         mpImpl( new AccessibleTextHelper_Impl() )
1526     {
1527         SolarMutexGuard aGuard;
1528
1529         SetEditSource( std::move(pEditSource) );
1530     }
1531
1532     AccessibleTextHelper::~AccessibleTextHelper()
1533     {
1534     }
1535
1536     const SvxEditSource& AccessibleTextHelper::GetEditSource() const
1537     {
1538 #ifdef DBG_UTIL
1539         mpImpl->CheckInvariants();
1540
1541         const SvxEditSource& aEditSource = mpImpl->GetEditSource();
1542
1543         mpImpl->CheckInvariants();
1544
1545         return aEditSource;
1546 #else
1547         return mpImpl->GetEditSource();
1548 #endif
1549     }
1550
1551     void AccessibleTextHelper::SetEditSource( ::std::unique_ptr< SvxEditSource > && pEditSource )
1552     {
1553 #ifdef DBG_UTIL
1554         // precondition: solar mutex locked
1555         DBG_TESTSOLARMUTEX();
1556
1557         mpImpl->CheckInvariants();
1558 #endif
1559
1560         mpImpl->SetEditSource( std::move(pEditSource) );
1561
1562 #ifdef DBG_UTIL
1563         mpImpl->CheckInvariants();
1564 #endif
1565     }
1566
1567     void AccessibleTextHelper::SetEventSource( const uno::Reference< XAccessible >& rInterface )
1568     {
1569 #ifdef DBG_UTIL
1570         mpImpl->CheckInvariants();
1571 #endif
1572
1573         mpImpl->SetEventSource( rInterface );
1574
1575 #ifdef DBG_UTIL
1576         mpImpl->CheckInvariants();
1577 #endif
1578     }
1579
1580     void AccessibleTextHelper::SetFocus( bool bHaveFocus )
1581     {
1582 #ifdef DBG_UTIL
1583         // precondition: solar mutex locked
1584         DBG_TESTSOLARMUTEX();
1585
1586         mpImpl->CheckInvariants();
1587 #endif
1588
1589         mpImpl->SetFocus( bHaveFocus );
1590
1591 #ifdef DBG_UTIL
1592         mpImpl->CheckInvariants();
1593 #endif
1594     }
1595
1596     bool AccessibleTextHelper::HaveFocus()
1597     {
1598 #ifdef DBG_UTIL
1599         mpImpl->CheckInvariants();
1600
1601         bool bRet( mpImpl->HaveFocus() );
1602
1603         mpImpl->CheckInvariants();
1604
1605         return bRet;
1606 #else
1607         return mpImpl->HaveFocus();
1608 #endif
1609     }
1610
1611     void AccessibleTextHelper::SetOffset( const Point& rPoint )
1612     {
1613 #ifdef DBG_UTIL
1614         // precondition: solar mutex locked
1615         DBG_TESTSOLARMUTEX();
1616
1617         mpImpl->CheckInvariants();
1618 #endif
1619
1620         mpImpl->SetOffset( rPoint );
1621
1622 #ifdef DBG_UTIL
1623         mpImpl->CheckInvariants();
1624 #endif
1625     }
1626
1627     void AccessibleTextHelper::SetStartIndex( sal_Int32 nOffset )
1628     {
1629 #ifdef DBG_UTIL
1630         // precondition: solar mutex locked
1631         DBG_TESTSOLARMUTEX();
1632
1633         mpImpl->CheckInvariants();
1634 #endif
1635
1636         mpImpl->SetStartIndex( nOffset );
1637
1638 #ifdef DBG_UTIL
1639         mpImpl->CheckInvariants();
1640 #endif
1641     }
1642
1643     sal_Int32 AccessibleTextHelper::GetStartIndex() const
1644     {
1645 #ifdef DBG_UTIL
1646         mpImpl->CheckInvariants();
1647
1648         sal_Int32 nOffset = mpImpl->GetStartIndex();
1649
1650         mpImpl->CheckInvariants();
1651
1652         return nOffset;
1653 #else
1654         return mpImpl->GetStartIndex();
1655 #endif
1656     }
1657
1658     void AccessibleTextHelper::SetAdditionalChildStates( const VectorOfStates& rChildStates )
1659     {
1660         mpImpl->SetAdditionalChildStates( rChildStates );
1661     }
1662
1663     void AccessibleTextHelper::UpdateChildren()
1664     {
1665 #ifdef DBG_UTIL
1666         // precondition: solar mutex locked
1667         DBG_TESTSOLARMUTEX();
1668
1669         mpImpl->CheckInvariants();
1670 #endif
1671
1672         mpImpl->UpdateVisibleChildren();
1673         mpImpl->UpdateBoundRect();
1674
1675         mpImpl->UpdateSelection();
1676
1677 #ifdef DBG_UTIL
1678         mpImpl->CheckInvariants();
1679 #endif
1680     }
1681
1682     void AccessibleTextHelper::Dispose()
1683     {
1684         // As Dispose calls ShutdownEditSource, which in turn
1685         // deregisters as listener on the edit source, have to lock
1686         // here
1687         SolarMutexGuard aGuard;
1688
1689 #ifdef DBG_UTIL
1690         mpImpl->CheckInvariants();
1691 #endif
1692
1693         mpImpl->Dispose();
1694
1695 #ifdef DBG_UTIL
1696         mpImpl->CheckInvariants();
1697 #endif
1698     }
1699
1700     // XAccessibleContext
1701     sal_Int32 AccessibleTextHelper::GetChildCount() const
1702     {
1703         SolarMutexGuard aGuard;
1704
1705 #ifdef DBG_UTIL
1706         mpImpl->CheckInvariants();
1707
1708         sal_Int32 nRet = mpImpl->getAccessibleChildCount();
1709
1710         mpImpl->CheckInvariants();
1711
1712         return nRet;
1713 #else
1714         return mpImpl->getAccessibleChildCount();
1715 #endif
1716     }
1717
1718     uno::Reference< XAccessible > AccessibleTextHelper::GetChild( sal_Int32 i )
1719     {
1720         SolarMutexGuard aGuard;
1721
1722 #ifdef DBG_UTIL
1723         mpImpl->CheckInvariants();
1724
1725         uno::Reference< XAccessible > xRet = mpImpl->getAccessibleChild( i );
1726
1727         mpImpl->CheckInvariants();
1728
1729         return xRet;
1730 #else
1731         return mpImpl->getAccessibleChild( i );
1732 #endif
1733     }
1734
1735     void AccessibleTextHelper::AddEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
1736     {
1737 #ifdef DBG_UTIL
1738         mpImpl->CheckInvariants();
1739
1740         mpImpl->addAccessibleEventListener( xListener );
1741
1742         mpImpl->CheckInvariants();
1743 #else
1744         mpImpl->addAccessibleEventListener( xListener );
1745 #endif
1746     }
1747
1748     void AccessibleTextHelper::RemoveEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
1749     {
1750 #ifdef DBG_UTIL
1751         mpImpl->CheckInvariants();
1752
1753         mpImpl->removeAccessibleEventListener( xListener );
1754
1755         mpImpl->CheckInvariants();
1756 #else
1757         mpImpl->removeAccessibleEventListener( xListener );
1758 #endif
1759     }
1760
1761     // XAccessibleComponent
1762     uno::Reference< XAccessible > AccessibleTextHelper::GetAt( const awt::Point& aPoint )
1763     {
1764         SolarMutexGuard aGuard;
1765
1766 #ifdef DBG_UTIL
1767         mpImpl->CheckInvariants();
1768
1769         uno::Reference< XAccessible > xChild = mpImpl->getAccessibleAtPoint( aPoint );
1770
1771         mpImpl->CheckInvariants();
1772
1773         return xChild;
1774 #else
1775         return mpImpl->getAccessibleAtPoint( aPoint );
1776 #endif
1777     }
1778
1779 } // end of namespace accessibility
1780
1781
1782 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */