svx/source/dialog/weldeditview.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 <config_wasm_strip.h>
  21
  22 #include <basegfx/matrix/b2dhommatrix.hxx>
  23 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  24 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  25 #include <com/sun/star/accessibility/XAccessible.hpp>
  26 #include <com/sun/star/accessibility/XAccessibleComponent.hpp>
  27 #include <com/sun/star/accessibility/XAccessibleContext2.hpp>
  28 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  29 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  30 #include <com/sun/star/lang/XServiceInfo.hpp>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <drawinglayer/processor2d/baseprocessor2d.hxx>
  33 #include <drawinglayer/processor2d/processor2dtools.hxx>
  34 #include <comphelper/lok.hxx>
  35 #include <editeng/eeitem.hxx>
  36 #include <editeng/fhgtitem.hxx>
  37 #include <editeng/fontitem.hxx>
  38 #include <editeng/outliner.hxx>
  39 #include <editeng/unoedhlp.hxx>
  40 #include <editeng/unoedsrc.hxx>
  41 #include <i18nlangtag/languagetag.hxx>
  42 #include <osl/diagnose.h>
  43 #include <svl/itempool.hxx>
  44 #include <svl/itemset.hxx>
  45 #include <sal/log.hxx>
  46 #include <svx/sdr/overlay/overlayselection.hxx>
  47 #include <svtools/optionsdrawinglayer.hxx>
  48 #include <svx/AccessibleTextHelper.hxx>
  49 #include <svx/weldeditview.hxx>
  50 #include <comphelper/diagnose_ex.hxx>
  51 #include <vcl/canvastools.hxx>
  52 #include <vcl/cursor.hxx>
  53 #include <vcl/event.hxx>
  54 #include <vcl/ptrstyle.hxx>
  55 #include <vcl/settings.hxx>
  56 #include <vcl/svapp.hxx>
  57 #include <vcl/window.hxx>
  58 #include <vcl/uitest/uiobject.hxx>
  59
  60 void WeldEditView::SetText(const OUString& rStr) { GetEditEngine()->SetText(rStr); }
  61
  62 OUString WeldEditView::GetText() const { return GetEditEngine()->GetText(); }
  63
  64 void WeldEditView::SetModifyHdl(const Link<LinkParamNone*, void>& rLink)
  65 {
  66     GetEditEngine()->SetModifyHdl(rLink);
  67 }
  68
  69 EditView* WeldEditView::GetEditView() const { return m_xEditView.get(); }
  70
  71 EditEngine* WeldEditView::GetEditEngine() const { return m_xEditEngine.get(); }
  72
  73 bool WeldEditView::HasSelection() const
  74 {
  75     EditView* pEditView = GetEditView();
  76     return pEditView && pEditView->HasSelection();
  77 }
  78
  79 void WeldEditView::Delete()
  80 {
  81     if (EditView* pEditView = GetEditView())
  82         pEditView->DeleteSelected();
  83 }
  84
  85 void WeldEditView::Cut()
  86 {
  87     if (EditView* pEditView = GetEditView())
  88         pEditView->Cut();
  89 }
  90
  91 void WeldEditView::Copy()
  92 {
  93     if (EditView* pEditView = GetEditView())
  94         pEditView->Copy();
  95 }
  96
  97 void WeldEditView::Paste()
  98 {
  99     if (EditView* pEditView = GetEditView())
 100         pEditView->Paste();
 101 }
 102
 103 WeldEditView::WeldEditView()
 104     : m_bAcceptsTab(false)
 105 {
 106 }
 107
 108 // tdf#127033 want to use UI font so override makeEditEngine to enable that
 109 void WeldEditView::makeEditEngine()
 110 {
 111     rtl::Reference<SfxItemPool> pItemPool = EditEngine::CreatePool();
 112
 113     vcl::Font aAppFont(Application::GetSettings().GetStyleSettings().GetAppFont());
 114
 115     pItemPool->SetUserDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(),
 116                                               u""_ustr, PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW,
 117                                               EE_CHAR_FONTINFO));
 118     pItemPool->SetUserDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(),
 119                                               u""_ustr, PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW,
 120                                               EE_CHAR_FONTINFO_CJK));
 121     pItemPool->SetUserDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(),
 122                                               u""_ustr, PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW,
 123                                               EE_CHAR_FONTINFO_CTL));
 124
 125     pItemPool->SetUserDefaultItem(
 126         SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT));
 127     pItemPool->SetUserDefaultItem(
 128         SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CJK));
 129     pItemPool->SetUserDefaultItem(
 130         SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CTL));
 131
 132     m_xEditEngine.reset(new EditEngine(pItemPool.get()));
 133 }
 134
 135 void WeldEditView::Resize()
 136 {
 137     if (EditView* pEditView = GetEditView())
 138     {
 139         OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 140         Size aOutputSize(rDevice.PixelToLogic(GetOutputSizePixel()));
 141         // Resizes the edit engine to adjust to the size of the output area
 142         pEditView->SetOutputArea(tools::Rectangle(Point(0, 0), aOutputSize));
 143         GetEditEngine()->SetPaperSize(aOutputSize);
 144         pEditView->ShowCursor();
 145
 146         const tools::Long nMaxVisAreaStart
 147             = pEditView->getEditEngine().GetTextHeight() - aOutputSize.Height();
 148         tools::Rectangle aVisArea(pEditView->GetVisArea());
 149         if (aVisArea.Top() > nMaxVisAreaStart)
 150         {
 151             aVisArea.SetTop(std::max<tools::Long>(nMaxVisAreaStart, 0));
 152             aVisArea.SetSize(aOutputSize);
 153             pEditView->SetVisArea(aVisArea);
 154             pEditView->ShowCursor();
 155         }
 156
 157         EditViewScrollStateChange();
 158     }
 159     weld::CustomWidgetController::Resize();
 160 }
 161
 162 void WeldEditView::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
 163 {
 164     DoPaint(rRenderContext, rRect);
 165 }
 166
 167 void WeldEditView::DoPaint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
 168 {
 169     rRenderContext.Push(vcl::PushFlags::ALL);
 170     rRenderContext.SetClipRegion();
 171
 172     std::vector<tools::Rectangle> aLogicRects;
 173
 174     if (EditView* pEditView = GetEditView())
 175     {
 176         pEditView->Paint(comphelper::LibreOfficeKit::isActive() ? rRenderContext.PixelToLogic(rRect)
 177                                                                 : rRect,
 178                          &rRenderContext);
 179
 180         if (HasFocus())
 181         {
 182             pEditView->ShowCursor(false);
 183             vcl::Cursor* pCursor = pEditView->GetCursor();
 184             pCursor->DrawToDevice(rRenderContext);
 185         }
 186
 187         // get logic selection
 188         pEditView->GetSelectionRectangles(aLogicRects);
 189     }
 190
 191     if (!aLogicRects.empty())
 192     {
 193         std::vector<basegfx::B2DRange> aLogicRanges;
 194         aLogicRanges.reserve(aLogicRects.size());
 195
 196         tools::Long nMinX(LONG_MAX), nMaxX(0), nMinY(LONG_MAX), nMaxY(0);
 197         for (const auto& aRect : aLogicRects)
 198         {
 199             nMinX = std::min(nMinX, aRect.Left());
 200             nMinY = std::min(nMinY, aRect.Top());
 201             nMaxX = std::max(nMaxX, aRect.Right());
 202             nMaxY = std::max(nMaxY, aRect.Bottom());
 203         }
 204
 205         const Size aLogicPixel(rRenderContext.PixelToLogic(Size(1, 1)));
 206         for (const auto& aRect : aLogicRects)
 207         {
 208             // Extend each range by one pixel so multiple lines touch each
 209             // other if adjacent, so the whole set is drawn with a single
 210             // border around the lot. But keep the selection within the
 211             // original max extents.
 212             auto nTop = aRect.Top();
 213             if (nTop > nMinY)
 214                 nTop -= aLogicPixel.Height();
 215             auto nBottom = aRect.Bottom();
 216             if (nBottom < nMaxY)
 217                 nBottom += aLogicPixel.Height();
 218             auto nLeft = aRect.Left();
 219             if (nLeft > nMinX)
 220                 nLeft -= aLogicPixel.Width();
 221             auto nRight = aRect.Right();
 222             if (nRight < nMaxX)
 223                 nRight += aLogicPixel.Width();
 224
 225             aLogicRanges.emplace_back(nLeft, nTop, nRight, nBottom);
 226         }
 227
 228         // get the system's highlight color
 229         const Color aHighlight(SvtOptionsDrawinglayer::getHilightColor());
 230
 231         sdr::overlay::OverlaySelection aCursorOverlay(sdr::overlay::OverlayType::Transparent,
 232                                                       aHighlight, std::move(aLogicRanges), true);
 233
 234         drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 235         aViewInformation2D.setViewTransformation(rRenderContext.GetViewTransformation());
 236         aViewInformation2D.setViewport(vcl::unotools::b2DRectangleFromRectangle(rRect));
 237
 238         std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> xProcessor(
 239             drawinglayer::processor2d::createProcessor2DFromOutputDevice(rRenderContext,
 240                                                                          aViewInformation2D));
 241
 242         xProcessor->process(aCursorOverlay.getOverlayObjectPrimitive2DSequence());
 243     }
 244
 245     rRenderContext.Pop();
 246 }
 247
 248 bool WeldEditView::MouseMove(const MouseEvent& rMEvt)
 249 {
 250     EditView* pEditView = GetEditView();
 251     return pEditView && pEditView->MouseMove(rMEvt);
 252 }
 253
 254 bool WeldEditView::MouseButtonDown(const MouseEvent& rMEvt)
 255 {
 256     if (!IsMouseCaptured())
 257         CaptureMouse();
 258
 259     if (!HasFocus() && CanFocus())
 260         GrabFocus();
 261
 262     EditView* pEditView = GetEditView();
 263     return pEditView && pEditView->MouseButtonDown(rMEvt);
 264 }
 265
 266 bool WeldEditView::MouseButtonUp(const MouseEvent& rMEvt)
 267 {
 268     if (IsMouseCaptured())
 269         ReleaseMouse();
 270     EditView* pEditView = GetEditView();
 271     return pEditView && pEditView->MouseButtonUp(rMEvt);
 272 }
 273
 274 bool WeldEditView::KeyInput(const KeyEvent& rKEvt)
 275 {
 276     EditView* pEditView = GetEditView();
 277
 278     sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode();
 279
 280     if (nKey == KEY_TAB && !GetAcceptsTab())
 281     {
 282         return false;
 283     }
 284     else if (pEditView && !pEditView->PostKeyEvent(rKEvt))
 285     {
 286         if (rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2())
 287         {
 288             if (nKey == KEY_A)
 289             {
 290                 if (GetEditEngine()->GetParagraphCount())
 291                 {
 292                     pEditView->SetSelection(ESelection::All());
 293                 }
 294                 return true;
 295             }
 296         }
 297
 298         return false;
 299     }
 300
 301     return true;
 302 }
 303
 304 bool WeldEditView::Command(const CommandEvent& rCEvt)
 305 {
 306     EditView* pEditView = GetEditView();
 307     if (!pEditView)
 308         return false;
 309     return pEditView->Command(rCEvt);
 310 }
 311
 312 Point WeldEditView::EditViewPointerPosPixel() const
 313 {
 314     return GetDrawingArea()->get_pointer_position();
 315 }
 316
 317 class WeldEditAccessible;
 318
 319 namespace
 320 {
 321 class WeldViewForwarder : public SvxViewForwarder
 322 {
 323     WeldEditAccessible& m_rEditAcc;
 324
 325     WeldViewForwarder(const WeldViewForwarder&) = delete;
 326     WeldViewForwarder& operator=(const WeldViewForwarder&) = delete;
 327
 328 public:
 329     explicit WeldViewForwarder(WeldEditAccessible& rAcc)
 330         : m_rEditAcc(rAcc)
 331     {
 332     }
 333
 334     virtual bool IsValid() const override;
 335     virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override;
 336     virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override;
 337 };
 338 }
 339
 340 class WeldEditAccessible;
 341
 342 namespace
 343 {
 344 class WeldEditSource;
 345
 346 /* analog to SvxEditEngineForwarder */
 347 class WeldTextForwarder : public SvxTextForwarder
 348 {
 349     WeldEditAccessible& m_rEditAcc;
 350     WeldEditSource& m_rEditSource;
 351
 352     DECL_LINK(NotifyHdl, EENotify&, void);
 353
 354     WeldTextForwarder(const WeldTextForwarder&) = delete;
 355     WeldTextForwarder& operator=(const WeldTextForwarder&) = delete;
 356
 357 public:
 358     WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource);
 359     virtual ~WeldTextForwarder() override;
 360
 361     virtual sal_Int32 GetParagraphCount() const override;
 362     virtual sal_Int32 GetTextLen(sal_Int32 nParagraph) const override;
 363     virtual OUString GetText(const ESelection& rSel) const override;
 364     virtual SfxItemSet GetAttribs(const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib
 365                                                           = EditEngineAttribs::All) const override;
 366     virtual SfxItemSet GetParaAttribs(sal_Int32 nPara) const override;
 367     virtual void SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet) override;
 368     virtual void RemoveAttribs(const ESelection& rSelection) override;
 369     virtual void GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const override;
 370
 371     virtual OUString GetStyleSheet(sal_Int32 nPara) const override;
 372     virtual void SetStyleSheet(sal_Int32 nPara, const OUString& rStyleName) override;
 373
 374     virtual SfxItemState GetItemState(const ESelection& rSel, sal_uInt16 nWhich) const override;
 375     virtual SfxItemState GetItemState(sal_Int32 nPara, sal_uInt16 nWhich) const override;
 376
 377     virtual void QuickInsertText(const OUString& rText, const ESelection& rSel) override;
 378     virtual void QuickInsertField(const SvxFieldItem& rFld, const ESelection& rSel) override;
 379     virtual void QuickSetAttribs(const SfxItemSet& rSet, const ESelection& rSel) override;
 380     virtual void QuickInsertLineBreak(const ESelection& rSel) override;
 381
 382     virtual SfxItemPool* GetPool() const override;
 383
 384     virtual OUString CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos,
 385                                     std::optional<Color>& rpTxtColor,
 386                                     std::optional<Color>& rpFldColor,
 387                                     std::optional<FontLineStyle>& rpFldLineStyle) override;
 388     virtual void FieldClicked(const SvxFieldItem&) override;
 389     virtual bool IsValid() const override;
 390
 391     virtual LanguageType GetLanguage(sal_Int32, sal_Int32) const override;
 392     virtual std::vector<EFieldInfo> GetFieldInfo(sal_Int32 nPara) const override;
 393     virtual EBulletInfo GetBulletInfo(sal_Int32 nPara) const override;
 394     virtual tools::Rectangle GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const override;
 395     virtual tools::Rectangle GetParaBounds(sal_Int32 nPara) const override;
 396     virtual MapMode GetMapMode() const override;
 397     virtual OutputDevice* GetRefDevice() const override;
 398     virtual bool GetIndexAtPoint(const Point&, sal_Int32& nPara, sal_Int32& nIndex) const override;
 399     virtual bool GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart,
 400                                 sal_Int32& nEnd) const override;
 401     virtual bool GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara,
 402                                  sal_Int32 nIndex, bool bInCell = false) const override;
 403     virtual sal_Int32 GetLineCount(sal_Int32 nPara) const override;
 404     virtual sal_Int32 GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const override;
 405     virtual void GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd,
 406                                    sal_Int32 nParagraph, sal_Int32 nLine) const override;
 407     virtual sal_Int32 GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nLine) const override;
 408     virtual bool Delete(const ESelection&) override;
 409     virtual bool InsertText(const OUString&, const ESelection&) override;
 410     virtual bool QuickFormatDoc(bool bFull = false) override;
 411
 412     virtual bool SupportsOutlineDepth() const override { return false; };
 413     virtual sal_Int16 GetDepth(sal_Int32 nPara) const override;
 414     virtual bool SetDepth(sal_Int32 nPara, sal_Int16 nNewDepth) override;
 415
 416     virtual const SfxItemSet* GetEmptyItemSetPtr() override;
 417     // implementation functions for XParagraphAppend and XTextPortionAppend
 418     virtual void AppendParagraph() override;
 419     virtual sal_Int32 AppendTextPortion(sal_Int32 nPara, const OUString& rText,
 420                                         const SfxItemSet& rSet) override;
 421
 422     virtual void CopyText(const SvxTextForwarder& rSource) override;
 423 };
 424
 425 /* analog to SvxEditEngineViewForwarder */
 426 class WeldEditViewForwarder : public SvxEditViewForwarder
 427 {
 428     WeldEditAccessible& m_rEditAcc;
 429
 430     WeldEditViewForwarder(const WeldEditViewForwarder&) = delete;
 431     WeldEditViewForwarder& operator=(const WeldEditViewForwarder&) = delete;
 432
 433 public:
 434     explicit WeldEditViewForwarder(WeldEditAccessible& rAcc);
 435
 436     virtual bool IsValid() const override;
 437
 438     virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override;
 439     virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override;
 440
 441     virtual bool GetSelection(ESelection& rSelection) const override;
 442     virtual bool SetSelection(const ESelection& rSelection) override;
 443     virtual bool Copy() override;
 444     virtual bool Cut() override;
 445     virtual bool Paste() override;
 446 };
 447
 448 class WeldEditSource : public SvxEditSource
 449 {
 450     SfxBroadcaster m_aBroadCaster;
 451     WeldViewForwarder m_aViewFwd;
 452     WeldTextForwarder m_aTextFwd;
 453     WeldEditViewForwarder m_aEditViewFwd;
 454     WeldEditAccessible& m_rEditAcc;
 455
 456     WeldEditSource(const WeldEditSource& rSrc)
 457         : SvxEditSource()
 458         , m_aViewFwd(rSrc.m_rEditAcc)
 459         , m_aTextFwd(rSrc.m_rEditAcc, *this)
 460         , m_aEditViewFwd(rSrc.m_rEditAcc)
 461         , m_rEditAcc(rSrc.m_rEditAcc)
 462     {
 463     }
 464
 465     WeldEditSource& operator=(const WeldEditSource&) = delete;
 466
 467 public:
 468     WeldEditSource(WeldEditAccessible& rAcc)
 469         : m_aViewFwd(rAcc)
 470         , m_aTextFwd(rAcc, *this)
 471         , m_aEditViewFwd(rAcc)
 472         , m_rEditAcc(rAcc)
 473     {
 474     }
 475
 476     virtual std::unique_ptr<SvxEditSource> Clone() const override
 477     {
 478         return std::unique_ptr<SvxEditSource>(new WeldEditSource(*this));
 479     }
 480
 481     virtual SvxTextForwarder* GetTextForwarder() override { return &m_aTextFwd; }
 482
 483     virtual SvxViewForwarder* GetViewForwarder() override { return &m_aViewFwd; }
 484
 485     virtual SvxEditViewForwarder* GetEditViewForwarder(bool /*bCreate*/) override
 486     {
 487         return &m_aEditViewFwd;
 488     }
 489
 490     virtual void UpdateData() override
 491     {
 492         // would possibly only by needed if the XText interface is implemented
 493         // and its text needs to be updated.
 494     }
 495     virtual SfxBroadcaster& GetBroadcaster() const override
 496     {
 497         return const_cast<WeldEditSource*>(this)->m_aBroadCaster;
 498     }
 499 };
 500 }
 501
 502 typedef cppu::WeakImplHelper<css::lang::XServiceInfo, css::accessibility::XAccessible,
 503                              css::accessibility::XAccessibleComponent,
 504                              css::accessibility::XAccessibleContext2,
 505                              css::accessibility::XAccessibleEventBroadcaster>
 506     WeldEditAccessibleBaseClass;
 507
 508 class WeldEditAccessible : public WeldEditAccessibleBaseClass
 509 {
 510     weld::CustomWidgetController* m_pController;
 511     EditEngine* m_pEditEngine;
 512     EditView* m_pEditView;
 513     std::unique_ptr<::accessibility::AccessibleTextHelper> m_xTextHelper;
 514
 515 public:
 516     WeldEditAccessible(weld::CustomWidgetController* pController)
 517         : m_pController(pController)
 518         , m_pEditEngine(nullptr)
 519         , m_pEditView(nullptr)
 520     {
 521     }
 522
 523     ::accessibility::AccessibleTextHelper* GetTextHelper() { return m_xTextHelper.get(); }
 524
 525     void Init(EditEngine* pEditEngine, EditView* pEditView)
 526     {
 527         m_pEditEngine = pEditEngine;
 528         m_pEditView = pEditView;
 529         m_xTextHelper.reset(
 530             new ::accessibility::AccessibleTextHelper(std::make_unique<WeldEditSource>(*this)));
 531         m_xTextHelper->SetEventSource(this);
 532     }
 533
 534     EditEngine* GetEditEngine() { return m_pEditEngine; }
 535     EditView* GetEditView() { return m_pEditView; }
 536
 537     void ClearWin()
 538     {
 539         // remove handler before current object gets destroyed
 540         // (avoid handler being called for already dead object)
 541         m_pEditEngine->SetNotifyHdl(Link<EENotify&, void>());
 542
 543         m_pEditEngine = nullptr;
 544         m_pEditView = nullptr;
 545         m_pController = nullptr; // implicitly results in AccessibleStateType::DEFUNC set
 546
 547         //! make TextHelper implicitly release C++ references to some core objects
 548         m_xTextHelper->SetEditSource(::std::unique_ptr<SvxEditSource>());
 549
 550         //! make TextHelper release references
 551         //! (e.g. the one set by the 'SetEventSource' call)
 552         m_xTextHelper->Dispose();
 553         m_xTextHelper.reset();
 554     }
 555
 556     // XAccessible
 557     virtual css::uno::Reference<css::accessibility::XAccessibleContext>
 558         SAL_CALL getAccessibleContext() override
 559     {
 560         return this;
 561     }
 562
 563     // XAccessibleComponent
 564     virtual sal_Bool SAL_CALL containsPoint(const css::awt::Point& rPoint) override
 565     {
 566         //! the arguments coordinates are relative to the current window !
 567         //! Thus the top left-point is (0, 0)
 568         SolarMutexGuard aGuard;
 569         if (!m_pController)
 570             throw css::uno::RuntimeException();
 571
 572         Size aSz(m_pController->GetOutputSizePixel());
 573         return rPoint.X >= 0 && rPoint.Y >= 0 && rPoint.X < aSz.Width() && rPoint.Y < aSz.Height();
 574     }
 575
 576     virtual css::uno::Reference<css::accessibility::XAccessible>
 577         SAL_CALL getAccessibleAtPoint(const css::awt::Point& rPoint) override
 578     {
 579         SolarMutexGuard aGuard;
 580         if (!m_xTextHelper)
 581             throw css::uno::RuntimeException();
 582
 583         return m_xTextHelper->GetAt(rPoint);
 584     }
 585
 586     virtual css::awt::Rectangle SAL_CALL getBounds() override
 587     {
 588         SolarMutexGuard aGuard;
 589         if (!m_pController)
 590             throw css::uno::RuntimeException();
 591
 592         const Point aOutPos;
 593         const Size aOutSize(m_pController->GetOutputSizePixel());
 594         css::awt::Rectangle aRet;
 595
 596         aRet.X = aOutPos.X();
 597         aRet.Y = aOutPos.Y();
 598         aRet.Width = aOutSize.Width();
 599         aRet.Height = aOutSize.Height();
 600
 601         return aRet;
 602     }
 603
 604     virtual css::awt::Point SAL_CALL getLocation() override
 605     {
 606         SolarMutexGuard aGuard;
 607         if (!m_pController)
 608             throw css::uno::RuntimeException();
 609
 610         const css::awt::Rectangle aRect(getBounds());
 611         css::awt::Point aRet;
 612
 613         aRet.X = aRect.X;
 614         aRet.Y = aRect.Y;
 615
 616         return aRet;
 617     }
 618
 619     virtual css::awt::Point SAL_CALL getLocationOnScreen() override
 620     {
 621         SolarMutexGuard aGuard;
 622         if (!m_pController)
 623             throw css::uno::RuntimeException();
 624
 625         css::awt::Point aScreenLoc(0, 0);
 626
 627         if (weld::DrawingArea* pDrawingArea = m_pController->GetDrawingArea())
 628         {
 629             AbsoluteScreenPixelPoint aPos = pDrawingArea->get_accessible_location_on_screen();
 630             aScreenLoc.X = aPos.X();
 631             aScreenLoc.Y = aPos.Y();
 632         }
 633
 634         return aScreenLoc;
 635     }
 636
 637     virtual css::awt::Size SAL_CALL getSize() override
 638     {
 639         SolarMutexGuard aGuard;
 640         if (!m_pController)
 641             throw css::uno::RuntimeException();
 642
 643         Size aSz(m_pController->GetOutputSizePixel());
 644         return css::awt::Size(aSz.Width(), aSz.Height());
 645     }
 646
 647     virtual void SAL_CALL grabFocus() override { m_pController->GrabFocus(); }
 648
 649     virtual sal_Int32 SAL_CALL getForeground() override
 650     {
 651         SolarMutexGuard aGuard;
 652         if (!m_pController)
 653             throw css::uno::RuntimeException();
 654
 655         Color nCol = m_pEditEngine->GetAutoColor();
 656         return static_cast<sal_Int32>(nCol);
 657     }
 658
 659     virtual sal_Int32 SAL_CALL getBackground() override
 660     {
 661         SolarMutexGuard aGuard;
 662         if (!m_pController)
 663             throw css::uno::RuntimeException();
 664
 665         Color nCol = m_pEditEngine->GetBackgroundColor();
 666         return static_cast<sal_Int32>(nCol);
 667     }
 668
 669     // XAccessibleContext
 670     virtual sal_Int64 SAL_CALL getAccessibleChildCount() override
 671     {
 672         if (m_xTextHelper)
 673             return m_xTextHelper->GetChildCount();
 674         return 0;
 675     }
 676
 677     virtual css::uno::Reference<css::accessibility::XAccessible>
 678         SAL_CALL getAccessibleChild(sal_Int64 i) override
 679     {
 680         if (m_xTextHelper)
 681             return m_xTextHelper->GetChild(i);
 682         throw css::lang::IndexOutOfBoundsException(); // there is no child...
 683     }
 684
 685     virtual css::uno::Reference<css::accessibility::XAccessible>
 686         SAL_CALL getAccessibleParent() override
 687     {
 688         SolarMutexGuard aGuard;
 689         if (!m_pController)
 690             throw css::uno::RuntimeException();
 691
 692         return m_pController->GetDrawingArea()->get_accessible_parent();
 693     }
 694
 695     virtual sal_Int64 SAL_CALL getAccessibleIndexInParent() override
 696     {
 697         SolarMutexGuard aGuard;
 698         if (!m_pController)
 699             throw css::uno::RuntimeException();
 700
 701         // -1 for child not found/no parent (according to specification)
 702         sal_Int64 nRet = -1;
 703
 704         css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent());
 705         if (!xParent)
 706             return nRet;
 707
 708         try
 709         {
 710             css::uno::Reference<css::accessibility::XAccessibleContext> xParentContext(
 711                 xParent->getAccessibleContext());
 712
 713             //  iterate over parent's children and search for this object
 714             if (xParentContext.is())
 715             {
 716                 sal_Int64 nChildCount = xParentContext->getAccessibleChildCount();
 717                 for (sal_Int64 nChild = 0; (nChild < nChildCount) && (-1 == nRet); ++nChild)
 718                 {
 719                     css::uno::Reference<css::accessibility::XAccessible> xChild(
 720                         xParentContext->getAccessibleChild(nChild));
 721                     if (xChild.get() == this)
 722                         nRet = nChild;
 723                 }
 724             }
 725         }
 726         catch (const css::uno::Exception&)
 727         {
 728             TOOLS_WARN_EXCEPTION("svx", "WeldEditAccessible::getAccessibleIndexInParent");
 729         }
 730
 731         return nRet;
 732     }
 733
 734     virtual sal_Int16 SAL_CALL getAccessibleRole() override
 735     {
 736         return css::accessibility::AccessibleRole::TEXT_FRAME;
 737     }
 738
 739     virtual OUString SAL_CALL getAccessibleDescription() override
 740     {
 741         SolarMutexGuard aGuard;
 742
 743         OUString aRet;
 744
 745         if (m_pController)
 746         {
 747             aRet = m_pController->GetAccessibleDescription();
 748         }
 749
 750         return aRet;
 751     }
 752
 753     virtual OUString SAL_CALL getAccessibleId() override
 754     {
 755         SolarMutexGuard aGuard;
 756
 757         if (m_pController)
 758             return m_pController->GetAccessibleId();
 759
 760         return OUString();
 761     }
 762
 763     virtual OUString SAL_CALL getAccessibleName() override
 764     {
 765         SolarMutexGuard aGuard;
 766
 767         OUString aRet;
 768
 769         if (m_pController)
 770         {
 771             aRet = m_pController->GetAccessibleName();
 772         }
 773
 774         return aRet;
 775     }
 776
 777     virtual css::uno::Reference<css::accessibility::XAccessibleRelationSet>
 778         SAL_CALL getAccessibleRelationSet() override
 779     {
 780         SolarMutexGuard aGuard;
 781         if (!m_pController)
 782             throw css::uno::RuntimeException();
 783
 784         return m_pController->GetDrawingArea()->get_accessible_relation_set();
 785     }
 786
 787     virtual sal_Int64 SAL_CALL getAccessibleStateSet() override
 788     {
 789         SolarMutexGuard aGuard;
 790         sal_Int64 nStateSet = 0;
 791
 792         if (!m_pController || !m_xTextHelper)
 793             nStateSet |= css::accessibility::AccessibleStateType::DEFUNC;
 794         else
 795         {
 796             nStateSet |= css::accessibility::AccessibleStateType::MULTI_LINE;
 797             nStateSet |= css::accessibility::AccessibleStateType::ENABLED;
 798             nStateSet |= css::accessibility::AccessibleStateType::EDITABLE;
 799             nStateSet |= css::accessibility::AccessibleStateType::FOCUSABLE;
 800             nStateSet |= css::accessibility::AccessibleStateType::SELECTABLE;
 801             if (m_pController->HasFocus())
 802                 nStateSet |= css::accessibility::AccessibleStateType::FOCUSED;
 803             if (m_pController->IsActive())
 804                 nStateSet |= css::accessibility::AccessibleStateType::ACTIVE;
 805             if (m_pController->IsVisible())
 806                 nStateSet |= css::accessibility::AccessibleStateType::SHOWING;
 807             if (m_pController->IsReallyVisible())
 808                 nStateSet |= css::accessibility::AccessibleStateType::VISIBLE;
 809             if (COL_TRANSPARENT != m_pEditEngine->GetBackgroundColor())
 810                 nStateSet |= css::accessibility::AccessibleStateType::OPAQUE;
 811         }
 812
 813         return nStateSet;
 814     }
 815
 816     virtual css::lang::Locale SAL_CALL getLocale() override
 817     {
 818         SolarMutexGuard aGuard;
 819         return LanguageTag(m_pEditEngine->GetDefaultLanguage()).getLocale();
 820     }
 821
 822     // XAccessibleEventBroadcaster
 823     virtual void SAL_CALL addAccessibleEventListener(
 824         const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override
 825     {
 826         if (!m_xTextHelper) // not disposing (about to destroy view shell)
 827             return;
 828         m_xTextHelper->AddEventListener(rListener);
 829     }
 830
 831     virtual void SAL_CALL removeAccessibleEventListener(
 832         const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override
 833     {
 834         if (!m_xTextHelper) // not disposing (about to destroy view shell)
 835             return;
 836         m_xTextHelper->RemoveEventListener(rListener);
 837     }
 838
 839     virtual OUString SAL_CALL getImplementationName() override
 840     {
 841         return u"WeldEditAccessible"_ustr;
 842     }
 843
 844     virtual sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override
 845     {
 846         return cppu::supportsService(this, rServiceName);
 847     }
 848
 849     virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
 850     {
 851         return { u"css::accessibility::Accessible"_ustr,
 852                  u"css::accessibility::AccessibleComponent"_ustr,
 853                  u"css::accessibility::AccessibleContext"_ustr };
 854     }
 855 };
 856
 857 css::uno::Reference<css::accessibility::XAccessible> WeldEditView::CreateAccessible()
 858 {
 859 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 860     if (!m_xAccessible.is())
 861         m_xAccessible.set(new WeldEditAccessible(this));
 862 #endif
 863     return m_xAccessible;
 864 }
 865
 866 WeldEditView::~WeldEditView()
 867 {
 868 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 869     if (m_xAccessible.is())
 870     {
 871         m_xAccessible->ClearWin(); // make Accessible nonfunctional
 872         m_xAccessible.clear();
 873     }
 874 #endif
 875 }
 876
 877 bool WeldViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; }
 878
 879 Point WeldViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const
 880 {
 881     EditView* pEditView = m_rEditAcc.GetEditView();
 882     if (!pEditView)
 883         return Point();
 884     OutputDevice& rOutDev = pEditView->GetOutputDevice();
 885     MapMode aMapMode(rOutDev.GetMapMode());
 886     Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit())));
 887     aMapMode.SetOrigin(Point());
 888     return rOutDev.LogicToPixel(aPoint, aMapMode);
 889 }
 890
 891 Point WeldViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const
 892 {
 893     EditView* pEditView = m_rEditAcc.GetEditView();
 894     if (!pEditView)
 895         return Point();
 896     OutputDevice& rOutDev = pEditView->GetOutputDevice();
 897     MapMode aMapMode(rOutDev.GetMapMode());
 898     aMapMode.SetOrigin(Point());
 899     Point aPoint(rOutDev.PixelToLogic(rPoint, aMapMode));
 900     return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode);
 901 }
 902
 903 WeldTextForwarder::WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource)
 904     : m_rEditAcc(rAcc)
 905     , m_rEditSource(rSource)
 906 {
 907     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 908     if (pEditEngine)
 909         pEditEngine->SetNotifyHdl(LINK(this, WeldTextForwarder, NotifyHdl));
 910 }
 911
 912 WeldTextForwarder::~WeldTextForwarder()
 913 {
 914     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 915     if (pEditEngine)
 916         pEditEngine->SetNotifyHdl(Link<EENotify&, void>());
 917 }
 918
 919 IMPL_LINK(WeldTextForwarder, NotifyHdl, EENotify&, rNotify, void)
 920 {
 921     if (EditEngine* pEditEngine = m_rEditAcc.GetEditEngine())
 922     {
 923         if (rNotify.eNotificationType == EE_NOTIFY_PROCESSNOTIFICATIONS
 924             && !pEditEngine->IsUpdateLayout())
 925         {
 926             // tdf#143088 an UpdateMode of false will just to on to cause
 927             // AccessibleTextHelper_Impl::GetTextForwarder to throw an
 928             // exception as a Frozen EditEngine is considered Invalid so return
 929             // early instead
 930             return;
 931         }
 932     }
 933
 934     ::std::unique_ptr<SfxHint> aHint = SvxEditSourceHelper::EENotification2Hint(&rNotify);
 935     if (aHint)
 936         m_rEditSource.GetBroadcaster().Broadcast(*aHint);
 937 }
 938
 939 sal_Int32 WeldTextForwarder::GetParagraphCount() const
 940 {
 941     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 942     return pEditEngine ? pEditEngine->GetParagraphCount() : 0;
 943 }
 944
 945 sal_Int32 WeldTextForwarder::GetTextLen(sal_Int32 nParagraph) const
 946 {
 947     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 948     return pEditEngine ? pEditEngine->GetTextLen(nParagraph) : 0;
 949 }
 950
 951 OUString WeldTextForwarder::GetText(const ESelection& rSel) const
 952 {
 953     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 954     OUString aRet;
 955     if (pEditEngine)
 956         aRet = pEditEngine->GetText(rSel);
 957     return convertLineEnd(aRet, GetSystemLineEnd());
 958 }
 959
 960 SfxItemSet WeldTextForwarder::GetAttribs(const ESelection& rSel,
 961                                          EditEngineAttribs nOnlyHardAttrib) const
 962 {
 963     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 964     assert(pEditEngine && "EditEngine missing");
 965     if (rSel.start.nPara == rSel.end.nPara)
 966     {
 967         GetAttribsFlags nFlags = GetAttribsFlags::NONE;
 968         switch (nOnlyHardAttrib)
 969         {
 970             case EditEngineAttribs::All:
 971                 nFlags = GetAttribsFlags::ALL;
 972                 break;
 973             case EditEngineAttribs::OnlyHard:
 974                 nFlags = GetAttribsFlags::CHARATTRIBS;
 975                 break;
 976             default:
 977                 SAL_WARN("svx", "unknown flags for WeldTextForwarder::GetAttribs");
 978         }
 979
 980         return pEditEngine->GetAttribs(rSel.start.nPara, rSel.start.nIndex, rSel.end.nIndex,
 981                                        nFlags);
 982     }
 983     else
 984     {
 985         return pEditEngine->GetAttribs(rSel, nOnlyHardAttrib);
 986     }
 987 }
 988
 989 SfxItemSet WeldTextForwarder::GetParaAttribs(sal_Int32 nPara) const
 990 {
 991     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 992     assert(pEditEngine && "EditEngine missing");
 993
 994     SfxItemSet aSet(pEditEngine->GetParaAttribs(nPara));
 995
 996     sal_uInt16 nWhich = EE_PARA_START;
 997     while (nWhich <= EE_PARA_END)
 998     {
 999         if (aSet.GetItemState(nWhich) != SfxItemState::SET)
1000         {
1001             if (pEditEngine->HasParaAttrib(nPara, nWhich))
1002                 aSet.Put(pEditEngine->GetParaAttrib(nPara, nWhich));
1003         }
1004         nWhich++;
1005     }
1006
1007     return aSet;
1008 }
1009
1010 void WeldTextForwarder::SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet)
1011 {
1012     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1013     if (pEditEngine)
1014         pEditEngine->SetParaAttribs(nPara, rSet);
1015 }
1016
1017 SfxItemPool* WeldTextForwarder::GetPool() const
1018 {
1019     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1020     return pEditEngine ? pEditEngine->GetEmptyItemSet().GetPool() : nullptr;
1021 }
1022
1023 void WeldTextForwarder::RemoveAttribs(const ESelection& rSelection)
1024 {
1025     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1026     if (pEditEngine)
1027         pEditEngine->RemoveAttribs(rSelection, false /*bRemoveParaAttribs*/, 0);
1028 }
1029
1030 void WeldTextForwarder::GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const
1031 {
1032     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1033     if (pEditEngine)
1034         pEditEngine->GetPortions(nPara, rList);
1035 }
1036
1037 OUString WeldTextForwarder::GetStyleSheet(sal_Int32 nPara) const
1038 {
1039     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1040     if (auto pStyle = pEditEngine ? pEditEngine->GetStyleSheet(nPara) : nullptr)
1041         return pStyle->GetName();
1042     return OUString();
1043 }
1044
1045 void WeldTextForwarder::SetStyleSheet(sal_Int32 nPara, const OUString& rStyleName)
1046 {
1047     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1048     auto pStyleSheetPool = pEditEngine ? pEditEngine->GetStyleSheetPool() : nullptr;
1049     if (auto pStyle
1050         = pStyleSheetPool ? pStyleSheetPool->Find(rStyleName, SfxStyleFamily::Para) : nullptr)
1051         pEditEngine->SetStyleSheet(nPara, static_cast<SfxStyleSheet*>(pStyle));
1052 }
1053
1054 void WeldTextForwarder::QuickInsertText(const OUString& rText, const ESelection& rSel)
1055 {
1056     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1057     if (pEditEngine)
1058         pEditEngine->QuickInsertText(rText, rSel);
1059 }
1060
1061 void WeldTextForwarder::QuickInsertLineBreak(const ESelection& rSel)
1062 {
1063     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1064     if (pEditEngine)
1065         pEditEngine->QuickInsertLineBreak(rSel);
1066 }
1067
1068 void WeldTextForwarder::QuickInsertField(const SvxFieldItem& rFld, const ESelection& rSel)
1069 {
1070     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1071     if (pEditEngine)
1072         pEditEngine->QuickInsertField(rFld, rSel);
1073 }
1074
1075 void WeldTextForwarder::QuickSetAttribs(const SfxItemSet& rSet, const ESelection& rSel)
1076 {
1077     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1078     if (pEditEngine)
1079         pEditEngine->QuickSetAttribs(rSet, rSel);
1080 }
1081
1082 bool WeldTextForwarder::IsValid() const
1083 {
1084     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1085     // cannot reliably query EditEngine state
1086     // while in the middle of an update
1087     return pEditEngine && pEditEngine->IsUpdateLayout();
1088 }
1089
1090 OUString WeldTextForwarder::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara,
1091                                            sal_Int32 nPos, std::optional<Color>& rpTxtColor,
1092                                            std::optional<Color>& rpFldColor,
1093                                            std::optional<FontLineStyle>& rpFldLineStyle)
1094 {
1095     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1096     return pEditEngine ? pEditEngine->CalcFieldValue(rField, nPara, nPos, rpTxtColor, rpFldColor,
1097                                                      rpFldLineStyle)
1098                        : OUString();
1099 }
1100
1101 void WeldTextForwarder::FieldClicked(const SvxFieldItem&) {}
1102
1103 static SfxItemState GetSvxEditEngineItemState(EditEngine const& rEditEngine, const ESelection& rSel,
1104                                               sal_uInt16 nWhich)
1105 {
1106     std::vector<EECharAttrib> aAttribs;
1107
1108     const SfxPoolItem* pLastItem = nullptr;
1109
1110     SfxItemState eState = SfxItemState::DEFAULT;
1111
1112     // check all paragraphs inside the selection
1113     for (sal_Int32 nPara = rSel.start.nPara; nPara <= rSel.end.nPara; nPara++)
1114     {
1115         SfxItemState eParaState = SfxItemState::DEFAULT;
1116
1117         // calculate start and endpos for this paragraph
1118         sal_Int32 nPos = 0;
1119         if (rSel.start.nPara == nPara)
1120             nPos = rSel.start.nIndex;
1121
1122         sal_Int32 nEndPos = rSel.end.nIndex;
1123         if (rSel.end.nPara != nPara)
1124             nEndPos = rEditEngine.GetTextLen(nPara);
1125
1126         // get list of char attribs
1127         rEditEngine.GetCharAttribs(nPara, aAttribs);
1128
1129         bool bEmpty = true; // we found no item inside the selection of this paragraph
1130         bool bGaps = false; // we found items but there are gaps between them
1131         sal_Int32 nLastEnd = nPos;
1132
1133         const SfxPoolItem* pParaItem = nullptr;
1134
1135         for (const auto& rAttrib : aAttribs)
1136         {
1137             assert(rAttrib.pAttr && "GetCharAttribs gives corrupt data");
1138
1139             const bool bEmptyPortion = (rAttrib.nStart == rAttrib.nEnd);
1140             if ((!bEmptyPortion && (rAttrib.nStart >= nEndPos))
1141                 || (bEmptyPortion && (rAttrib.nStart > nEndPos)))
1142                 break; // break if we are already behind our selection
1143
1144             if ((!bEmptyPortion && (rAttrib.nEnd <= nPos))
1145                 || (bEmptyPortion && (rAttrib.nEnd < nPos)))
1146                 continue; // or if the attribute ends before our selection
1147
1148             if (rAttrib.pAttr->Which() != nWhich)
1149                 continue; // skip if is not the searched item
1150
1151             // if we already found an item
1152             if (pParaItem)
1153             {
1154                 // ... and its different to this one than the state is don't care
1155                 if (*pParaItem != *(rAttrib.pAttr))
1156                     return SfxItemState::INVALID;
1157             }
1158             else
1159             {
1160                 pParaItem = rAttrib.pAttr;
1161             }
1162
1163             if (bEmpty)
1164                 bEmpty = false;
1165
1166             if (!bGaps && rAttrib.nStart > nLastEnd)
1167                 bGaps = true;
1168
1169             nLastEnd = rAttrib.nEnd;
1170         }
1171
1172         if (!bEmpty && !bGaps && nLastEnd < (nEndPos - 1))
1173             bGaps = true;
1174         if (bEmpty)
1175             eParaState = SfxItemState::DEFAULT;
1176         else if (bGaps)
1177             eParaState = SfxItemState::INVALID;
1178         else
1179             eParaState = SfxItemState::SET;
1180
1181         // if we already found an item check if we found the same
1182         if (pLastItem)
1183         {
1184             if ((pParaItem == nullptr) || (*pLastItem != *pParaItem))
1185                 return SfxItemState::INVALID;
1186         }
1187         else
1188         {
1189             pLastItem = pParaItem;
1190             eState = eParaState;
1191         }
1192     }
1193
1194     return eState;
1195 }
1196
1197 SfxItemState WeldTextForwarder::GetItemState(const ESelection& rSel, sal_uInt16 nWhich) const
1198 {
1199     SfxItemState nState = SfxItemState::DISABLED;
1200     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1201     if (pEditEngine)
1202         nState = GetSvxEditEngineItemState(*pEditEngine, rSel, nWhich);
1203     return nState;
1204 }
1205
1206 SfxItemState WeldTextForwarder::GetItemState(sal_Int32 nPara, sal_uInt16 nWhich) const
1207 {
1208     SfxItemState nState = SfxItemState::DISABLED;
1209     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1210     if (pEditEngine)
1211     {
1212         const SfxItemSet& rSet = pEditEngine->GetParaAttribs(nPara);
1213         nState = rSet.GetItemState(nWhich);
1214     }
1215     return nState;
1216 }
1217
1218 LanguageType WeldTextForwarder::GetLanguage(sal_Int32 nPara, sal_Int32 nIndex) const
1219 {
1220     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1221     return pEditEngine ? pEditEngine->GetLanguage(nPara, nIndex).nLang : LANGUAGE_NONE;
1222 }
1223
1224 std::vector<EFieldInfo> WeldTextForwarder::GetFieldInfo(sal_Int32 nPara) const
1225 {
1226     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1227     if (!pEditEngine)
1228         return {};
1229     return pEditEngine->GetFieldInfo(nPara);
1230 }
1231
1232 EBulletInfo WeldTextForwarder::GetBulletInfo(sal_Int32 /*nPara*/) const { return EBulletInfo(); }
1233
1234 tools::Rectangle WeldTextForwarder::GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const
1235 {
1236     tools::Rectangle aRect(0, 0, 0, 0);
1237     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1238
1239     if (pEditEngine)
1240     {
1241         // Handle virtual position one-past-the end of the string
1242         if (nIndex >= pEditEngine->GetTextLen(nPara))
1243         {
1244             if (nIndex)
1245                 aRect = pEditEngine->GetCharacterBounds(EPaM(nPara, nIndex - 1));
1246
1247             aRect.Move(aRect.Right() - aRect.Left(), 0);
1248             aRect.SetSize(Size(1, pEditEngine->GetTextHeight()));
1249         }
1250         else
1251         {
1252             aRect = pEditEngine->GetCharacterBounds(EPaM(nPara, nIndex));
1253         }
1254     }
1255     return aRect;
1256 }
1257
1258 tools::Rectangle WeldTextForwarder::GetParaBounds(sal_Int32 nPara) const
1259 {
1260     tools::Rectangle aRect(0, 0, 0, 0);
1261     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1262
1263     if (pEditEngine)
1264     {
1265         const Point aPnt = pEditEngine->GetDocPosTopLeft(nPara);
1266         const sal_Int32 nWidth = pEditEngine->CalcTextWidth();
1267         const sal_Int32 nHeight = pEditEngine->GetTextHeight(nPara);
1268         aRect = tools::Rectangle(aPnt.X(), aPnt.Y(), aPnt.X() + nWidth, aPnt.Y() + nHeight);
1269     }
1270
1271     return aRect;
1272 }
1273
1274 MapMode WeldTextForwarder::GetMapMode() const
1275 {
1276     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1277     return pEditEngine ? pEditEngine->GetRefMapMode() : MapMode(MapUnit::Map100thMM);
1278 }
1279
1280 OutputDevice* WeldTextForwarder::GetRefDevice() const
1281 {
1282     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1283     return pEditEngine ? pEditEngine->GetRefDevice() : nullptr;
1284 }
1285
1286 bool WeldTextForwarder::GetIndexAtPoint(const Point& rPos, sal_Int32& nPara,
1287                                         sal_Int32& nIndex) const
1288 {
1289     bool bRes = false;
1290     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1291     if (pEditEngine)
1292     {
1293         EPaM aDocPos = pEditEngine->FindDocPosition(rPos);
1294         nPara = aDocPos.nPara;
1295         nIndex = aDocPos.nIndex;
1296         bRes = true;
1297     }
1298     return bRes;
1299 }
1300
1301 bool WeldTextForwarder::GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart,
1302                                        sal_Int32& nEnd) const
1303 {
1304     bool bRes = false;
1305     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1306     if (pEditEngine)
1307     {
1308         ESelection aRes
1309             = pEditEngine->GetWord(ESelection(nPara, nIndex), css::i18n::WordType::DICTIONARY_WORD);
1310
1311         if (aRes.start.nPara == nPara && aRes.start.nPara == aRes.end.nPara)
1312         {
1313             nStart = aRes.start.nIndex;
1314             nEnd = aRes.end.nIndex;
1315
1316             bRes = true;
1317         }
1318     }
1319
1320     return bRes;
1321 }
1322
1323 bool WeldTextForwarder::GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex,
1324                                         sal_Int32 nPara, sal_Int32 nIndex, bool bInCell) const
1325 {
1326     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1327     if (!pEditEngine)
1328         return false;
1329     SvxEditSourceHelper::GetAttributeRun(nStartIndex, nEndIndex, *pEditEngine, nPara, nIndex,
1330                                          bInCell);
1331     return true;
1332 }
1333
1334 sal_Int32 WeldTextForwarder::GetLineCount(sal_Int32 nPara) const
1335 {
1336     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1337     return pEditEngine ? pEditEngine->GetLineCount(nPara) : 0;
1338 }
1339
1340 sal_Int32 WeldTextForwarder::GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const
1341 {
1342     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1343     return pEditEngine ? pEditEngine->GetLineLen(nPara, nLine) : 0;
1344 }
1345
1346 void WeldTextForwarder::GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd,
1347                                           sal_Int32 nPara, sal_Int32 nLine) const
1348 {
1349     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1350     if (pEditEngine)
1351         pEditEngine->GetLineBoundaries(rStart, rEnd, nPara, nLine);
1352     else
1353         rStart = rEnd = 0;
1354 }
1355
1356 sal_Int32 WeldTextForwarder::GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nIndex) const
1357 {
1358     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1359     return pEditEngine ? pEditEngine->GetLineNumberAtIndex(nPara, nIndex) : 0;
1360 }
1361
1362 bool WeldTextForwarder::QuickFormatDoc(bool /*bFull*/)
1363 {
1364     bool bRes = false;
1365     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1366     if (pEditEngine)
1367     {
1368         pEditEngine->QuickFormatDoc();
1369         bRes = true;
1370     }
1371     return bRes;
1372 }
1373
1374 sal_Int16 WeldTextForwarder::GetDepth(sal_Int32 /*nPara*/) const
1375 {
1376     // math has no outliner...
1377     return -1;
1378 }
1379
1380 bool WeldTextForwarder::SetDepth(sal_Int32 /*nPara*/, sal_Int16 nNewDepth)
1381 {
1382     // math has no outliner...
1383     return -1 == nNewDepth; // is it the value from 'GetDepth' ?
1384 }
1385
1386 bool WeldTextForwarder::Delete(const ESelection& rSelection)
1387 {
1388     bool bRes = false;
1389     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1390     if (pEditEngine)
1391     {
1392         pEditEngine->QuickDelete(rSelection);
1393         pEditEngine->QuickFormatDoc();
1394         bRes = true;
1395     }
1396     return bRes;
1397 }
1398
1399 bool WeldTextForwarder::InsertText(const OUString& rStr, const ESelection& rSelection)
1400 {
1401     bool bRes = false;
1402     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1403     if (pEditEngine)
1404     {
1405         pEditEngine->QuickInsertText(rStr, rSelection);
1406         pEditEngine->QuickFormatDoc();
1407         bRes = true;
1408     }
1409     return bRes;
1410 }
1411
1412 const SfxItemSet* WeldTextForwarder::GetEmptyItemSetPtr()
1413 {
1414     const SfxItemSet* pItemSet = nullptr;
1415     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1416     if (pEditEngine)
1417     {
1418         pItemSet = &pEditEngine->GetEmptyItemSet();
1419     }
1420     return pItemSet;
1421 }
1422
1423 void WeldTextForwarder::AppendParagraph()
1424 {
1425     // append an empty paragraph
1426     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1427     if (pEditEngine)
1428     {
1429         sal_Int32 nParaCount = pEditEngine->GetParagraphCount();
1430         pEditEngine->InsertParagraph(nParaCount, OUString());
1431     }
1432 }
1433
1434 sal_Int32 WeldTextForwarder::AppendTextPortion(sal_Int32 nPara, const OUString& rText,
1435                                                const SfxItemSet& rSet)
1436 {
1437     sal_uInt16 nRes = 0;
1438     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1439     if (pEditEngine && nPara < pEditEngine->GetParagraphCount())
1440     {
1441         // append text
1442         ESelection aSel(nPara, pEditEngine->GetTextLen(nPara));
1443         pEditEngine->QuickInsertText(rText, aSel);
1444
1445         // set attributes for new appended text
1446         nRes = aSel.end.nIndex = pEditEngine->GetTextLen(nPara);
1447         pEditEngine->QuickSetAttribs(rSet, aSel);
1448     }
1449     return nRes;
1450 }
1451
1452 void WeldTextForwarder::CopyText(const SvxTextForwarder& rSource)
1453 {
1454     const WeldTextForwarder* pSourceForwarder = dynamic_cast<const WeldTextForwarder*>(&rSource);
1455     if (!pSourceForwarder)
1456         return;
1457     EditEngine* pSourceEditEngine = pSourceForwarder->m_rEditAcc.GetEditEngine();
1458     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1459     if (pEditEngine && pSourceEditEngine)
1460     {
1461         std::unique_ptr<EditTextObject> pNewTextObject = pSourceEditEngine->CreateTextObject();
1462         pEditEngine->SetText(*pNewTextObject);
1463     }
1464 }
1465
1466 WeldEditViewForwarder::WeldEditViewForwarder(WeldEditAccessible& rAcc)
1467     : m_rEditAcc(rAcc)
1468 {
1469 }
1470
1471 bool WeldEditViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; }
1472
1473 Point WeldEditViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const
1474 {
1475     EditView* pEditView = m_rEditAcc.GetEditView();
1476     if (!pEditView)
1477         return Point();
1478     OutputDevice& rOutDev = pEditView->GetOutputDevice();
1479     MapMode aMapMode(rOutDev.GetMapMode());
1480     Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit())));
1481     aMapMode.SetOrigin(Point());
1482     return rOutDev.LogicToPixel(aPoint, aMapMode);
1483 }
1484
1485 Point WeldEditViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const
1486 {
1487     EditView* pEditView = m_rEditAcc.GetEditView();
1488     if (!pEditView)
1489         return Point();
1490     OutputDevice& rOutDev = pEditView->GetOutputDevice();
1491     MapMode aMapMode(rOutDev.GetMapMode());
1492     aMapMode.SetOrigin(Point());
1493     Point aPoint(rOutDev.PixelToLogic(rPoint, aMapMode));
1494     return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode);
1495 }
1496
1497 bool WeldEditViewForwarder::GetSelection(ESelection& rSelection) const
1498 {
1499     bool bRes = false;
1500     EditView* pEditView = m_rEditAcc.GetEditView();
1501     if (pEditView)
1502     {
1503         rSelection = pEditView->GetSelection();
1504         bRes = true;
1505     }
1506     return bRes;
1507 }
1508
1509 bool WeldEditViewForwarder::SetSelection(const ESelection& rSelection)
1510 {
1511     bool bRes = false;
1512     EditView* pEditView = m_rEditAcc.GetEditView();
1513     if (pEditView)
1514     {
1515         pEditView->SetSelection(rSelection);
1516         bRes = true;
1517     }
1518     return bRes;
1519 }
1520
1521 bool WeldEditViewForwarder::Copy()
1522 {
1523     bool bRes = false;
1524     EditView* pEditView = m_rEditAcc.GetEditView();
1525     if (pEditView)
1526     {
1527         pEditView->Copy();
1528         bRes = true;
1529     }
1530     return bRes;
1531 }
1532
1533 bool WeldEditViewForwarder::Cut()
1534 {
1535     bool bRes = false;
1536     EditView* pEditView = m_rEditAcc.GetEditView();
1537     if (pEditView)
1538     {
1539         pEditView->Cut();
1540         bRes = true;
1541     }
1542     return bRes;
1543 }
1544
1545 bool WeldEditViewForwarder::Paste()
1546 {
1547     bool bRes = false;
1548     EditView* pEditView = m_rEditAcc.GetEditView();
1549     if (pEditView)
1550     {
1551         pEditView->Paste();
1552         bRes = true;
1553     }
1554     return bRes;
1555 }
1556
1557 void WeldEditView::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1558 {
1559     Size aSize(pDrawingArea->get_size_request());
1560     if (aSize.Width() == -1)
1561         aSize.setWidth(500);
1562     if (aSize.Height() == -1)
1563         aSize.setHeight(100);
1564     pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
1565
1566     SetOutputSizePixel(aSize);
1567
1568     weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
1569
1570     EnableRTL(false);
1571
1572     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1573     Color aBgColor = rStyleSettings.GetFieldColor();
1574
1575     OutputDevice& rDevice = pDrawingArea->get_ref_device();
1576
1577     rDevice.SetMapMode(MapMode(MapUnit::MapTwip));
1578     rDevice.SetBackground(aBgColor);
1579
1580     Size aOutputSize(rDevice.PixelToLogic(aSize));
1581
1582     makeEditEngine();
1583     m_xEditEngine->SetPaperSize(aOutputSize);
1584     m_xEditEngine->SetRefDevice(&rDevice);
1585
1586     m_xEditEngine->SetControlWord(m_xEditEngine->GetControlWord() | EEControlBits::MARKFIELDS);
1587
1588     m_xEditView.reset(new EditView(m_xEditEngine.get(), nullptr));
1589     m_xEditView->setEditViewCallbacks(this);
1590     m_xEditView->SetOutputArea(tools::Rectangle(Point(0, 0), aOutputSize));
1591
1592     m_xEditView->SetBackgroundColor(aBgColor);
1593     m_xEditEngine->SetBackgroundColor(aBgColor);
1594     m_xEditEngine->InsertView(m_xEditView.get());
1595
1596     pDrawingArea->set_cursor(PointerStyle::Text);
1597
1598 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1599     InitAccessible();
1600 #endif
1601 }
1602
1603 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1604 void WeldEditView::InitAccessible()
1605 {
1606     if (m_xAccessible.is())
1607         m_xAccessible->Init(GetEditEngine(), GetEditView());
1608 }
1609 #endif
1610
1611 int WeldEditView::GetSurroundingText(OUString& rSurrounding)
1612 {
1613     EditView* pEditView = GetEditView();
1614     if (!pEditView)
1615         return -1;
1616     rSurrounding = pEditView->GetSurroundingText();
1617     return pEditView->GetSurroundingTextSelection().Min();
1618 }
1619
1620 bool WeldEditView::DeleteSurroundingText(const Selection& rRange)
1621 {
1622     EditView* pEditView = GetEditView();
1623     if (!pEditView)
1624         return false;
1625     return pEditView->DeleteSurroundingText(rRange);
1626 }
1627
1628 void WeldEditView::GetFocus()
1629 {
1630     EditView* pEditView = GetEditView();
1631     if (pEditView)
1632     {
1633         pEditView->ShowCursor(false);
1634         Invalidate(); // redraw with cursor
1635     }
1636
1637     weld::CustomWidgetController::GetFocus();
1638
1639 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1640     if (m_xAccessible.is())
1641     {
1642         // Note: will implicitly send the AccessibleStateType::FOCUSED event
1643         ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper();
1644         if (pHelper)
1645             pHelper->SetFocus();
1646     }
1647 #endif
1648 }
1649
1650 void WeldEditView::LoseFocus()
1651 {
1652     weld::CustomWidgetController::LoseFocus();
1653     Invalidate(); // redraw without cursor
1654
1655 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1656     if (m_xAccessible.is())
1657     {
1658         // Note: will implicitly send the AccessibleStateType::FOCUSED event
1659         ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper();
1660         if (pHelper)
1661             pHelper->SetFocus(false);
1662     }
1663 #endif
1664 }
1665
1666 bool WeldEditView::CanFocus() const { return true; }
1667
1668 css::uno::Reference<css::datatransfer::dnd::XDropTarget> WeldEditView::GetDropTarget()
1669 {
1670     if (!m_xDropTarget)
1671         m_xDropTarget = weld::CustomWidgetController::GetDropTarget();
1672     return m_xDropTarget;
1673 }
1674
1675 css::uno::Reference<css::datatransfer::clipboard::XClipboard> WeldEditView::GetClipboard() const
1676 {
1677     return weld::CustomWidgetController::GetClipboard();
1678 }
1679
1680 void WeldEditView::EditViewSelectionChange()
1681 {
1682     Invalidate();
1683
1684 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1685     if (m_xAccessible.is())
1686     {
1687         ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper();
1688         if (pHelper)
1689             pHelper->UpdateSelection();
1690     }
1691 #endif
1692 }
1693
1694 namespace
1695 {
1696 class WeldEditViewUIObject final : public DrawingAreaUIObject
1697 {
1698 private:
1699     WeldEditView* mpEditView;
1700
1701 public:
1702     WeldEditViewUIObject(const VclPtr<vcl::Window>& rDrawingArea)
1703         : DrawingAreaUIObject(rDrawingArea)
1704         , mpEditView(static_cast<WeldEditView*>(mpController))
1705     {
1706     }
1707
1708     static std::unique_ptr<UIObject> create(vcl::Window* pWindow)
1709     {
1710         return std::unique_ptr<UIObject>(new WeldEditViewUIObject(pWindow));
1711     }
1712
1713     virtual StringMap get_state() override
1714     {
1715         StringMap aMap = WindowUIObject::get_state();
1716         aMap[u"Text"_ustr] = mpEditView->GetText();
1717         return aMap;
1718     }
1719
1720 private:
1721     virtual OUString get_name() const override { return u"WeldEditViewUIObject"_ustr; }
1722 };
1723 }
1724
1725 FactoryFunction WeldEditView::GetUITestFactory() const { return WeldEditViewUIObject::create; }
1726
1727 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */