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