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/XAccessibleContext.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->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(),
 116                                               "", PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW,
 117                                               EE_CHAR_FONTINFO));
 118     pItemPool->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(),
 119                                               "", PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW,
 120                                               EE_CHAR_FONTINFO_CJK));
 121     pItemPool->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(),
 122                                               "", PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW,
 123                                               EE_CHAR_FONTINFO_CTL));
 124
 125     pItemPool->SetPoolDefaultItem(
 126         SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT));
 127     pItemPool->SetPoolDefaultItem(
 128         SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CJK));
 129     pItemPool->SetPoolDefaultItem(
 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                 EditEngine* pEditEngine = GetEditEngine();
 291                 sal_Int32 nPar = pEditEngine->GetParagraphCount();
 292                 if (nPar)
 293                 {
 294                     sal_Int32 nLen = pEditEngine->GetTextLen(nPar - 1);
 295                     pEditView->SetSelection(ESelection(0, 0, nPar - 1, nLen));
 296                 }
 297                 return true;
 298             }
 299         }
 300
 301         return false;
 302     }
 303
 304     return true;
 305 }
 306
 307 bool WeldEditView::Command(const CommandEvent& rCEvt)
 308 {
 309     EditView* pEditView = GetEditView();
 310     if (!pEditView)
 311         return false;
 312     return pEditView->Command(rCEvt);
 313 }
 314
 315 Point WeldEditView::EditViewPointerPosPixel() const
 316 {
 317     return GetDrawingArea()->get_pointer_position();
 318 }
 319
 320 class WeldEditAccessible;
 321
 322 namespace
 323 {
 324 class WeldViewForwarder : public SvxViewForwarder
 325 {
 326     WeldEditAccessible& m_rEditAcc;
 327
 328     WeldViewForwarder(const WeldViewForwarder&) = delete;
 329     WeldViewForwarder& operator=(const WeldViewForwarder&) = delete;
 330
 331 public:
 332     explicit WeldViewForwarder(WeldEditAccessible& rAcc)
 333         : m_rEditAcc(rAcc)
 334     {
 335     }
 336
 337     virtual bool IsValid() const override;
 338     virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override;
 339     virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override;
 340 };
 341 }
 342
 343 class WeldEditAccessible;
 344
 345 namespace
 346 {
 347 class WeldEditSource;
 348
 349 /* analog to SvxEditEngineForwarder */
 350 class WeldTextForwarder : public SvxTextForwarder
 351 {
 352     WeldEditAccessible& m_rEditAcc;
 353     WeldEditSource& m_rEditSource;
 354
 355     DECL_LINK(NotifyHdl, EENotify&, void);
 356
 357     WeldTextForwarder(const WeldTextForwarder&) = delete;
 358     WeldTextForwarder& operator=(const WeldTextForwarder&) = delete;
 359
 360 public:
 361     WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource);
 362     virtual ~WeldTextForwarder() override;
 363
 364     virtual sal_Int32 GetParagraphCount() const override;
 365     virtual sal_Int32 GetTextLen(sal_Int32 nParagraph) const override;
 366     virtual OUString GetText(const ESelection& rSel) const override;
 367     virtual SfxItemSet GetAttribs(const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib
 368                                                           = EditEngineAttribs::All) const override;
 369     virtual SfxItemSet GetParaAttribs(sal_Int32 nPara) const override;
 370     virtual void SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet) override;
 371     virtual void RemoveAttribs(const ESelection& rSelection) override;
 372     virtual void GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const 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 sal_Int32 GetFieldCount(sal_Int32 nPara) const override;
 393     virtual EFieldInfo GetFieldInfo(sal_Int32 nPara, sal_uInt16 nField) const override;
 394     virtual EBulletInfo GetBulletInfo(sal_Int32 nPara) const override;
 395     virtual tools::Rectangle GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const override;
 396     virtual tools::Rectangle GetParaBounds(sal_Int32 nPara) const override;
 397     virtual MapMode GetMapMode() const override;
 398     virtual OutputDevice* GetRefDevice() const override;
 399     virtual bool GetIndexAtPoint(const Point&, sal_Int32& nPara, sal_Int32& nIndex) const override;
 400     virtual bool GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart,
 401                                 sal_Int32& nEnd) const override;
 402     virtual bool GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara,
 403                                  sal_Int32 nIndex, bool bInCell = false) const override;
 404     virtual sal_Int32 GetLineCount(sal_Int32 nPara) const override;
 405     virtual sal_Int32 GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const override;
 406     virtual void GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd,
 407                                    sal_Int32 nParagraph, sal_Int32 nLine) const override;
 408     virtual sal_Int32 GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nLine) const override;
 409     virtual bool Delete(const ESelection&) override;
 410     virtual bool InsertText(const OUString&, const ESelection&) override;
 411     virtual bool QuickFormatDoc(bool bFull = false) override;
 412
 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::XAccessibleContext,
 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             Point 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 getAccessibleName() override
 754     {
 755         SolarMutexGuard aGuard;
 756
 757         OUString aRet;
 758
 759         if (m_pController)
 760         {
 761             aRet = m_pController->GetAccessibleName();
 762         }
 763
 764         return aRet;
 765     }
 766
 767     virtual css::uno::Reference<css::accessibility::XAccessibleRelationSet>
 768         SAL_CALL getAccessibleRelationSet() override
 769     {
 770         SolarMutexGuard aGuard;
 771         if (!m_pController)
 772             throw css::uno::RuntimeException();
 773
 774         return m_pController->GetDrawingArea()->get_accessible_relation_set();
 775     }
 776
 777     virtual sal_Int64 SAL_CALL getAccessibleStateSet() override
 778     {
 779         SolarMutexGuard aGuard;
 780         sal_Int64 nStateSet = 0;
 781
 782         if (!m_pController || !m_xTextHelper)
 783             nStateSet |= css::accessibility::AccessibleStateType::DEFUNC;
 784         else
 785         {
 786             nStateSet |= css::accessibility::AccessibleStateType::MULTI_LINE;
 787             nStateSet |= css::accessibility::AccessibleStateType::ENABLED;
 788             nStateSet |= css::accessibility::AccessibleStateType::EDITABLE;
 789             nStateSet |= css::accessibility::AccessibleStateType::FOCUSABLE;
 790             nStateSet |= css::accessibility::AccessibleStateType::SELECTABLE;
 791             if (m_pController->HasFocus())
 792                 nStateSet |= css::accessibility::AccessibleStateType::FOCUSED;
 793             if (m_pController->IsActive())
 794                 nStateSet |= css::accessibility::AccessibleStateType::ACTIVE;
 795             if (m_pController->IsVisible())
 796                 nStateSet |= css::accessibility::AccessibleStateType::SHOWING;
 797             if (m_pController->IsReallyVisible())
 798                 nStateSet |= css::accessibility::AccessibleStateType::VISIBLE;
 799             if (COL_TRANSPARENT != m_pEditEngine->GetBackgroundColor())
 800                 nStateSet |= css::accessibility::AccessibleStateType::OPAQUE;
 801         }
 802
 803         return nStateSet;
 804     }
 805
 806     virtual css::lang::Locale SAL_CALL getLocale() override
 807     {
 808         SolarMutexGuard aGuard;
 809         return LanguageTag(m_pEditEngine->GetDefaultLanguage()).getLocale();
 810     }
 811
 812     // XAccessibleEventBroadcaster
 813     virtual void SAL_CALL addAccessibleEventListener(
 814         const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override
 815     {
 816         if (!m_xTextHelper) // not disposing (about to destroy view shell)
 817             return;
 818         m_xTextHelper->AddEventListener(rListener);
 819     }
 820
 821     virtual void SAL_CALL removeAccessibleEventListener(
 822         const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override
 823     {
 824         if (!m_xTextHelper) // not disposing (about to destroy view shell)
 825             return;
 826         m_xTextHelper->RemoveEventListener(rListener);
 827     }
 828
 829     virtual OUString SAL_CALL getImplementationName() override { return "WeldEditAccessible"; }
 830
 831     virtual sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override
 832     {
 833         return cppu::supportsService(this, rServiceName);
 834     }
 835
 836     virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
 837     {
 838         return { "css::accessibility::Accessible", "css::accessibility::AccessibleComponent",
 839                  "css::accessibility::AccessibleContext" };
 840     }
 841 };
 842
 843 css::uno::Reference<css::accessibility::XAccessible> WeldEditView::CreateAccessible()
 844 {
 845 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 846     if (!m_xAccessible.is())
 847         m_xAccessible.set(new WeldEditAccessible(this));
 848 #endif
 849     return m_xAccessible;
 850 }
 851
 852 WeldEditView::~WeldEditView()
 853 {
 854 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 855     if (m_xAccessible.is())
 856     {
 857         m_xAccessible->ClearWin(); // make Accessible nonfunctional
 858         m_xAccessible.clear();
 859     }
 860 #endif
 861 }
 862
 863 bool WeldViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; }
 864
 865 Point WeldViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const
 866 {
 867     EditView* pEditView = m_rEditAcc.GetEditView();
 868     if (!pEditView)
 869         return Point();
 870     OutputDevice& rOutDev = pEditView->GetOutputDevice();
 871     MapMode aMapMode(rOutDev.GetMapMode());
 872     Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit())));
 873     aMapMode.SetOrigin(Point());
 874     return rOutDev.LogicToPixel(aPoint, aMapMode);
 875 }
 876
 877 Point WeldViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const
 878 {
 879     EditView* pEditView = m_rEditAcc.GetEditView();
 880     if (!pEditView)
 881         return Point();
 882     OutputDevice& rOutDev = pEditView->GetOutputDevice();
 883     MapMode aMapMode(rOutDev.GetMapMode());
 884     aMapMode.SetOrigin(Point());
 885     Point aPoint(rOutDev.PixelToLogic(rPoint, aMapMode));
 886     return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode);
 887 }
 888
 889 WeldTextForwarder::WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource)
 890     : m_rEditAcc(rAcc)
 891     , m_rEditSource(rSource)
 892 {
 893     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 894     if (pEditEngine)
 895         pEditEngine->SetNotifyHdl(LINK(this, WeldTextForwarder, NotifyHdl));
 896 }
 897
 898 WeldTextForwarder::~WeldTextForwarder()
 899 {
 900     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 901     if (pEditEngine)
 902         pEditEngine->SetNotifyHdl(Link<EENotify&, void>());
 903 }
 904
 905 IMPL_LINK(WeldTextForwarder, NotifyHdl, EENotify&, rNotify, void)
 906 {
 907     if (EditEngine* pEditEngine = m_rEditAcc.GetEditEngine())
 908     {
 909         if (rNotify.eNotificationType == EE_NOTIFY_PROCESSNOTIFICATIONS
 910             && !pEditEngine->IsUpdateLayout())
 911         {
 912             // tdf#143088 an UpdateMode of false will just to on to cause
 913             // AccessibleTextHelper_Impl::GetTextForwarder to throw an
 914             // exception as a Frozen EditEngine is considered Invalid so return
 915             // early instead
 916             return;
 917         }
 918     }
 919
 920     ::std::unique_ptr<SfxHint> aHint = SvxEditSourceHelper::EENotification2Hint(&rNotify);
 921     if (aHint)
 922         m_rEditSource.GetBroadcaster().Broadcast(*aHint);
 923 }
 924
 925 sal_Int32 WeldTextForwarder::GetParagraphCount() const
 926 {
 927     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 928     return pEditEngine ? pEditEngine->GetParagraphCount() : 0;
 929 }
 930
 931 sal_Int32 WeldTextForwarder::GetTextLen(sal_Int32 nParagraph) const
 932 {
 933     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 934     return pEditEngine ? pEditEngine->GetTextLen(nParagraph) : 0;
 935 }
 936
 937 OUString WeldTextForwarder::GetText(const ESelection& rSel) const
 938 {
 939     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 940     OUString aRet;
 941     if (pEditEngine)
 942         aRet = pEditEngine->GetText(rSel);
 943     return convertLineEnd(aRet, GetSystemLineEnd());
 944 }
 945
 946 SfxItemSet WeldTextForwarder::GetAttribs(const ESelection& rSel,
 947                                          EditEngineAttribs nOnlyHardAttrib) const
 948 {
 949     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 950     assert(pEditEngine && "EditEngine missing");
 951     if (rSel.nStartPara == rSel.nEndPara)
 952     {
 953         GetAttribsFlags nFlags = GetAttribsFlags::NONE;
 954         switch (nOnlyHardAttrib)
 955         {
 956             case EditEngineAttribs::All:
 957                 nFlags = GetAttribsFlags::ALL;
 958                 break;
 959             case EditEngineAttribs::OnlyHard:
 960                 nFlags = GetAttribsFlags::CHARATTRIBS;
 961                 break;
 962             default:
 963                 SAL_WARN("svx", "unknown flags for WeldTextForwarder::GetAttribs");
 964         }
 965
 966         return pEditEngine->GetAttribs(rSel.nStartPara, rSel.nStartPos, rSel.nEndPos, nFlags);
 967     }
 968     else
 969     {
 970         return pEditEngine->GetAttribs(rSel, nOnlyHardAttrib);
 971     }
 972 }
 973
 974 SfxItemSet WeldTextForwarder::GetParaAttribs(sal_Int32 nPara) const
 975 {
 976     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 977     assert(pEditEngine && "EditEngine missing");
 978
 979     SfxItemSet aSet(pEditEngine->GetParaAttribs(nPara));
 980
 981     sal_uInt16 nWhich = EE_PARA_START;
 982     while (nWhich <= EE_PARA_END)
 983     {
 984         if (aSet.GetItemState(nWhich) != SfxItemState::SET)
 985         {
 986             if (pEditEngine->HasParaAttrib(nPara, nWhich))
 987                 aSet.Put(pEditEngine->GetParaAttrib(nPara, nWhich));
 988         }
 989         nWhich++;
 990     }
 991
 992     return aSet;
 993 }
 994
 995 void WeldTextForwarder::SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet)
 996 {
 997     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
 998     if (pEditEngine)
 999         pEditEngine->SetParaAttribs(nPara, rSet);
1000 }
1001
1002 SfxItemPool* WeldTextForwarder::GetPool() const
1003 {
1004     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1005     return pEditEngine ? pEditEngine->GetEmptyItemSet().GetPool() : nullptr;
1006 }
1007
1008 void WeldTextForwarder::RemoveAttribs(const ESelection& rSelection)
1009 {
1010     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1011     if (pEditEngine)
1012         pEditEngine->RemoveAttribs(rSelection, false /*bRemoveParaAttribs*/, 0);
1013 }
1014
1015 void WeldTextForwarder::GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const
1016 {
1017     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1018     if (pEditEngine)
1019         pEditEngine->GetPortions(nPara, rList);
1020 }
1021
1022 void WeldTextForwarder::QuickInsertText(const OUString& rText, const ESelection& rSel)
1023 {
1024     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1025     if (pEditEngine)
1026         pEditEngine->QuickInsertText(rText, rSel);
1027 }
1028
1029 void WeldTextForwarder::QuickInsertLineBreak(const ESelection& rSel)
1030 {
1031     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1032     if (pEditEngine)
1033         pEditEngine->QuickInsertLineBreak(rSel);
1034 }
1035
1036 void WeldTextForwarder::QuickInsertField(const SvxFieldItem& rFld, const ESelection& rSel)
1037 {
1038     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1039     if (pEditEngine)
1040         pEditEngine->QuickInsertField(rFld, rSel);
1041 }
1042
1043 void WeldTextForwarder::QuickSetAttribs(const SfxItemSet& rSet, const ESelection& rSel)
1044 {
1045     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1046     if (pEditEngine)
1047         pEditEngine->QuickSetAttribs(rSet, rSel);
1048 }
1049
1050 bool WeldTextForwarder::IsValid() const
1051 {
1052     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1053     // cannot reliably query EditEngine state
1054     // while in the middle of an update
1055     return pEditEngine && pEditEngine->IsUpdateLayout();
1056 }
1057
1058 OUString WeldTextForwarder::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara,
1059                                            sal_Int32 nPos, std::optional<Color>& rpTxtColor,
1060                                            std::optional<Color>& rpFldColor,
1061                                            std::optional<FontLineStyle>& rpFldLineStyle)
1062 {
1063     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1064     return pEditEngine ? pEditEngine->CalcFieldValue(rField, nPara, nPos, rpTxtColor, rpFldColor,
1065                                                      rpFldLineStyle)
1066                        : OUString();
1067 }
1068
1069 void WeldTextForwarder::FieldClicked(const SvxFieldItem&) {}
1070
1071 static SfxItemState GetSvxEditEngineItemState(EditEngine const& rEditEngine, const ESelection& rSel,
1072                                               sal_uInt16 nWhich)
1073 {
1074     std::vector<EECharAttrib> aAttribs;
1075
1076     const SfxPoolItem* pLastItem = nullptr;
1077
1078     SfxItemState eState = SfxItemState::DEFAULT;
1079
1080     // check all paragraphs inside the selection
1081     for (sal_Int32 nPara = rSel.nStartPara; nPara <= rSel.nEndPara; nPara++)
1082     {
1083         SfxItemState eParaState = SfxItemState::DEFAULT;
1084
1085         // calculate start and endpos for this paragraph
1086         sal_Int32 nPos = 0;
1087         if (rSel.nStartPara == nPara)
1088             nPos = rSel.nStartPos;
1089
1090         sal_Int32 nEndPos = rSel.nEndPos;
1091         if (rSel.nEndPara != nPara)
1092             nEndPos = rEditEngine.GetTextLen(nPara);
1093
1094         // get list of char attribs
1095         rEditEngine.GetCharAttribs(nPara, aAttribs);
1096
1097         bool bEmpty = true; // we found no item inside the selection of this paragraph
1098         bool bGaps = false; // we found items but there are gaps between them
1099         sal_Int32 nLastEnd = nPos;
1100
1101         const SfxPoolItem* pParaItem = nullptr;
1102
1103         for (const auto& rAttrib : aAttribs)
1104         {
1105             OSL_ENSURE(rAttrib.pAttr, "GetCharAttribs gives corrupt data");
1106
1107             const bool bEmptyPortion = (rAttrib.nStart == rAttrib.nEnd);
1108             if ((!bEmptyPortion && (rAttrib.nStart >= nEndPos))
1109                 || (bEmptyPortion && (rAttrib.nStart > nEndPos)))
1110                 break; // break if we are already behind our selection
1111
1112             if ((!bEmptyPortion && (rAttrib.nEnd <= nPos))
1113                 || (bEmptyPortion && (rAttrib.nEnd < nPos)))
1114                 continue; // or if the attribute ends before our selection
1115
1116             if (rAttrib.pAttr->Which() != nWhich)
1117                 continue; // skip if is not the searched item
1118
1119             // if we already found an item
1120             if (pParaItem)
1121             {
1122                 // ... and its different to this one than the state is don't care
1123                 if (*pParaItem != *(rAttrib.pAttr))
1124                     return SfxItemState::DONTCARE;
1125             }
1126             else
1127             {
1128                 pParaItem = rAttrib.pAttr;
1129             }
1130
1131             if (bEmpty)
1132                 bEmpty = false;
1133
1134             if (!bGaps && rAttrib.nStart > nLastEnd)
1135                 bGaps = true;
1136
1137             nLastEnd = rAttrib.nEnd;
1138         }
1139
1140         if (!bEmpty && !bGaps && nLastEnd < (nEndPos - 1))
1141             bGaps = true;
1142         if (bEmpty)
1143             eParaState = SfxItemState::DEFAULT;
1144         else if (bGaps)
1145             eParaState = SfxItemState::DONTCARE;
1146         else
1147             eParaState = SfxItemState::SET;
1148
1149         // if we already found an item check if we found the same
1150         if (pLastItem)
1151         {
1152             if ((pParaItem == nullptr) || (*pLastItem != *pParaItem))
1153                 return SfxItemState::DONTCARE;
1154         }
1155         else
1156         {
1157             pLastItem = pParaItem;
1158             eState = eParaState;
1159         }
1160     }
1161
1162     return eState;
1163 }
1164
1165 SfxItemState WeldTextForwarder::GetItemState(const ESelection& rSel, sal_uInt16 nWhich) const
1166 {
1167     SfxItemState nState = SfxItemState::DISABLED;
1168     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1169     if (pEditEngine)
1170         nState = GetSvxEditEngineItemState(*pEditEngine, rSel, nWhich);
1171     return nState;
1172 }
1173
1174 SfxItemState WeldTextForwarder::GetItemState(sal_Int32 nPara, sal_uInt16 nWhich) const
1175 {
1176     SfxItemState nState = SfxItemState::DISABLED;
1177     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1178     if (pEditEngine)
1179     {
1180         const SfxItemSet& rSet = pEditEngine->GetParaAttribs(nPara);
1181         nState = rSet.GetItemState(nWhich);
1182     }
1183     return nState;
1184 }
1185
1186 LanguageType WeldTextForwarder::GetLanguage(sal_Int32 nPara, sal_Int32 nIndex) const
1187 {
1188     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1189     return pEditEngine ? pEditEngine->GetLanguage(nPara, nIndex).nLang : LANGUAGE_NONE;
1190 }
1191
1192 sal_Int32 WeldTextForwarder::GetFieldCount(sal_Int32 nPara) const
1193 {
1194     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1195     return pEditEngine ? pEditEngine->GetFieldCount(nPara) : 0;
1196 }
1197
1198 EFieldInfo WeldTextForwarder::GetFieldInfo(sal_Int32 nPara, sal_uInt16 nField) const
1199 {
1200     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1201     return pEditEngine ? pEditEngine->GetFieldInfo(nPara, nField) : EFieldInfo();
1202 }
1203
1204 EBulletInfo WeldTextForwarder::GetBulletInfo(sal_Int32 /*nPara*/) const { return EBulletInfo(); }
1205
1206 tools::Rectangle WeldTextForwarder::GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const
1207 {
1208     tools::Rectangle aRect(0, 0, 0, 0);
1209     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1210
1211     if (pEditEngine)
1212     {
1213         // Handle virtual position one-past-the end of the string
1214         if (nIndex >= pEditEngine->GetTextLen(nPara))
1215         {
1216             if (nIndex)
1217                 aRect = pEditEngine->GetCharacterBounds(EPosition(nPara, nIndex - 1));
1218
1219             aRect.Move(aRect.Right() - aRect.Left(), 0);
1220             aRect.SetSize(Size(1, pEditEngine->GetTextHeight()));
1221         }
1222         else
1223         {
1224             aRect = pEditEngine->GetCharacterBounds(EPosition(nPara, nIndex));
1225         }
1226     }
1227     return aRect;
1228 }
1229
1230 tools::Rectangle WeldTextForwarder::GetParaBounds(sal_Int32 nPara) const
1231 {
1232     tools::Rectangle aRect(0, 0, 0, 0);
1233     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1234
1235     if (pEditEngine)
1236     {
1237         const Point aPnt = pEditEngine->GetDocPosTopLeft(nPara);
1238         const sal_Int32 nWidth = pEditEngine->CalcTextWidth();
1239         const sal_Int32 nHeight = pEditEngine->GetTextHeight(nPara);
1240         aRect = tools::Rectangle(aPnt.X(), aPnt.Y(), aPnt.X() + nWidth, aPnt.Y() + nHeight);
1241     }
1242
1243     return aRect;
1244 }
1245
1246 MapMode WeldTextForwarder::GetMapMode() const
1247 {
1248     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1249     return pEditEngine ? pEditEngine->GetRefMapMode() : MapMode(MapUnit::Map100thMM);
1250 }
1251
1252 OutputDevice* WeldTextForwarder::GetRefDevice() const
1253 {
1254     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1255     return pEditEngine ? pEditEngine->GetRefDevice() : nullptr;
1256 }
1257
1258 bool WeldTextForwarder::GetIndexAtPoint(const Point& rPos, sal_Int32& nPara,
1259                                         sal_Int32& nIndex) const
1260 {
1261     bool bRes = false;
1262     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1263     if (pEditEngine)
1264     {
1265         EPosition aDocPos = pEditEngine->FindDocPosition(rPos);
1266         nPara = aDocPos.nPara;
1267         nIndex = aDocPos.nIndex;
1268         bRes = true;
1269     }
1270     return bRes;
1271 }
1272
1273 bool WeldTextForwarder::GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart,
1274                                        sal_Int32& nEnd) const
1275 {
1276     bool bRes = false;
1277     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1278     if (pEditEngine)
1279     {
1280         ESelection aRes = pEditEngine->GetWord(ESelection(nPara, nIndex, nPara, nIndex),
1281                                                css::i18n::WordType::DICTIONARY_WORD);
1282
1283         if (aRes.nStartPara == nPara && aRes.nStartPara == aRes.nEndPara)
1284         {
1285             nStart = aRes.nStartPos;
1286             nEnd = aRes.nEndPos;
1287
1288             bRes = true;
1289         }
1290     }
1291
1292     return bRes;
1293 }
1294
1295 bool WeldTextForwarder::GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex,
1296                                         sal_Int32 nPara, sal_Int32 nIndex, bool bInCell) const
1297 {
1298     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1299     if (!pEditEngine)
1300         return false;
1301     SvxEditSourceHelper::GetAttributeRun(nStartIndex, nEndIndex, *pEditEngine, nPara, nIndex,
1302                                          bInCell);
1303     return true;
1304 }
1305
1306 sal_Int32 WeldTextForwarder::GetLineCount(sal_Int32 nPara) const
1307 {
1308     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1309     return pEditEngine ? pEditEngine->GetLineCount(nPara) : 0;
1310 }
1311
1312 sal_Int32 WeldTextForwarder::GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const
1313 {
1314     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1315     return pEditEngine ? pEditEngine->GetLineLen(nPara, nLine) : 0;
1316 }
1317
1318 void WeldTextForwarder::GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd,
1319                                           sal_Int32 nPara, sal_Int32 nLine) const
1320 {
1321     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1322     if (pEditEngine)
1323         pEditEngine->GetLineBoundaries(rStart, rEnd, nPara, nLine);
1324     else
1325         rStart = rEnd = 0;
1326 }
1327
1328 sal_Int32 WeldTextForwarder::GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nIndex) const
1329 {
1330     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1331     return pEditEngine ? pEditEngine->GetLineNumberAtIndex(nPara, nIndex) : 0;
1332 }
1333
1334 bool WeldTextForwarder::QuickFormatDoc(bool /*bFull*/)
1335 {
1336     bool bRes = false;
1337     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1338     if (pEditEngine)
1339     {
1340         pEditEngine->QuickFormatDoc();
1341         bRes = true;
1342     }
1343     return bRes;
1344 }
1345
1346 sal_Int16 WeldTextForwarder::GetDepth(sal_Int32 /*nPara*/) const
1347 {
1348     // math has no outliner...
1349     return -1;
1350 }
1351
1352 bool WeldTextForwarder::SetDepth(sal_Int32 /*nPara*/, sal_Int16 nNewDepth)
1353 {
1354     // math has no outliner...
1355     return -1 == nNewDepth; // is it the value from 'GetDepth' ?
1356 }
1357
1358 bool WeldTextForwarder::Delete(const ESelection& rSelection)
1359 {
1360     bool bRes = false;
1361     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1362     if (pEditEngine)
1363     {
1364         pEditEngine->QuickDelete(rSelection);
1365         pEditEngine->QuickFormatDoc();
1366         bRes = true;
1367     }
1368     return bRes;
1369 }
1370
1371 bool WeldTextForwarder::InsertText(const OUString& rStr, const ESelection& rSelection)
1372 {
1373     bool bRes = false;
1374     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1375     if (pEditEngine)
1376     {
1377         pEditEngine->QuickInsertText(rStr, rSelection);
1378         pEditEngine->QuickFormatDoc();
1379         bRes = true;
1380     }
1381     return bRes;
1382 }
1383
1384 const SfxItemSet* WeldTextForwarder::GetEmptyItemSetPtr()
1385 {
1386     const SfxItemSet* pItemSet = nullptr;
1387     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1388     if (pEditEngine)
1389     {
1390         pItemSet = &pEditEngine->GetEmptyItemSet();
1391     }
1392     return pItemSet;
1393 }
1394
1395 void WeldTextForwarder::AppendParagraph()
1396 {
1397     // append an empty paragraph
1398     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1399     if (pEditEngine)
1400     {
1401         sal_Int32 nParaCount = pEditEngine->GetParagraphCount();
1402         pEditEngine->InsertParagraph(nParaCount, OUString());
1403     }
1404 }
1405
1406 sal_Int32 WeldTextForwarder::AppendTextPortion(sal_Int32 nPara, const OUString& rText,
1407                                                const SfxItemSet& rSet)
1408 {
1409     sal_uInt16 nRes = 0;
1410     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1411     if (pEditEngine && nPara < pEditEngine->GetParagraphCount())
1412     {
1413         // append text
1414         ESelection aSel(nPara, pEditEngine->GetTextLen(nPara));
1415         pEditEngine->QuickInsertText(rText, aSel);
1416
1417         // set attributes for new appended text
1418         nRes = aSel.nEndPos = pEditEngine->GetTextLen(nPara);
1419         pEditEngine->QuickSetAttribs(rSet, aSel);
1420     }
1421     return nRes;
1422 }
1423
1424 void WeldTextForwarder::CopyText(const SvxTextForwarder& rSource)
1425 {
1426     const WeldTextForwarder* pSourceForwarder = dynamic_cast<const WeldTextForwarder*>(&rSource);
1427     if (!pSourceForwarder)
1428         return;
1429     EditEngine* pSourceEditEngine = pSourceForwarder->m_rEditAcc.GetEditEngine();
1430     EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();
1431     if (pEditEngine && pSourceEditEngine)
1432     {
1433         std::unique_ptr<EditTextObject> pNewTextObject = pSourceEditEngine->CreateTextObject();
1434         pEditEngine->SetText(*pNewTextObject);
1435     }
1436 }
1437
1438 WeldEditViewForwarder::WeldEditViewForwarder(WeldEditAccessible& rAcc)
1439     : m_rEditAcc(rAcc)
1440 {
1441 }
1442
1443 bool WeldEditViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; }
1444
1445 Point WeldEditViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const
1446 {
1447     EditView* pEditView = m_rEditAcc.GetEditView();
1448     if (!pEditView)
1449         return Point();
1450     OutputDevice& rOutDev = pEditView->GetOutputDevice();
1451     MapMode aMapMode(rOutDev.GetMapMode());
1452     Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit())));
1453     aMapMode.SetOrigin(Point());
1454     return rOutDev.LogicToPixel(aPoint, aMapMode);
1455 }
1456
1457 Point WeldEditViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const
1458 {
1459     EditView* pEditView = m_rEditAcc.GetEditView();
1460     if (!pEditView)
1461         return Point();
1462     OutputDevice& rOutDev = pEditView->GetOutputDevice();
1463     MapMode aMapMode(rOutDev.GetMapMode());
1464     aMapMode.SetOrigin(Point());
1465     Point aPoint(rOutDev.PixelToLogic(rPoint, aMapMode));
1466     return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode);
1467 }
1468
1469 bool WeldEditViewForwarder::GetSelection(ESelection& rSelection) const
1470 {
1471     bool bRes = false;
1472     EditView* pEditView = m_rEditAcc.GetEditView();
1473     if (pEditView)
1474     {
1475         rSelection = pEditView->GetSelection();
1476         bRes = true;
1477     }
1478     return bRes;
1479 }
1480
1481 bool WeldEditViewForwarder::SetSelection(const ESelection& rSelection)
1482 {
1483     bool bRes = false;
1484     EditView* pEditView = m_rEditAcc.GetEditView();
1485     if (pEditView)
1486     {
1487         pEditView->SetSelection(rSelection);
1488         bRes = true;
1489     }
1490     return bRes;
1491 }
1492
1493 bool WeldEditViewForwarder::Copy()
1494 {
1495     bool bRes = false;
1496     EditView* pEditView = m_rEditAcc.GetEditView();
1497     if (pEditView)
1498     {
1499         pEditView->Copy();
1500         bRes = true;
1501     }
1502     return bRes;
1503 }
1504
1505 bool WeldEditViewForwarder::Cut()
1506 {
1507     bool bRes = false;
1508     EditView* pEditView = m_rEditAcc.GetEditView();
1509     if (pEditView)
1510     {
1511         pEditView->Cut();
1512         bRes = true;
1513     }
1514     return bRes;
1515 }
1516
1517 bool WeldEditViewForwarder::Paste()
1518 {
1519     bool bRes = false;
1520     EditView* pEditView = m_rEditAcc.GetEditView();
1521     if (pEditView)
1522     {
1523         pEditView->Paste();
1524         bRes = true;
1525     }
1526     return bRes;
1527 }
1528
1529 void WeldEditView::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1530 {
1531     Size aSize(pDrawingArea->get_size_request());
1532     if (aSize.Width() == -1)
1533         aSize.setWidth(500);
1534     if (aSize.Height() == -1)
1535         aSize.setHeight(100);
1536     pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
1537
1538     SetOutputSizePixel(aSize);
1539
1540     weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
1541
1542     EnableRTL(false);
1543
1544     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1545     Color aBgColor = rStyleSettings.GetWindowColor();
1546
1547     OutputDevice& rDevice = pDrawingArea->get_ref_device();
1548
1549     rDevice.SetMapMode(MapMode(MapUnit::MapTwip));
1550     rDevice.SetBackground(aBgColor);
1551
1552     Size aOutputSize(rDevice.PixelToLogic(aSize));
1553
1554     makeEditEngine();
1555     m_xEditEngine->SetPaperSize(aOutputSize);
1556     m_xEditEngine->SetRefDevice(&rDevice);
1557
1558     m_xEditEngine->SetControlWord(m_xEditEngine->GetControlWord() | EEControlBits::MARKFIELDS);
1559
1560     m_xEditView.reset(new EditView(m_xEditEngine.get(), nullptr));
1561     m_xEditView->setEditViewCallbacks(this);
1562     m_xEditView->SetOutputArea(tools::Rectangle(Point(0, 0), aOutputSize));
1563
1564     m_xEditView->SetBackgroundColor(aBgColor);
1565     m_xEditEngine->SetBackgroundColor(aBgColor);
1566     m_xEditEngine->InsertView(m_xEditView.get());
1567
1568     pDrawingArea->set_cursor(PointerStyle::Text);
1569
1570 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1571     InitAccessible();
1572 #endif
1573 }
1574
1575 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1576 void WeldEditView::InitAccessible()
1577 {
1578     if (m_xAccessible.is())
1579         m_xAccessible->Init(GetEditEngine(), GetEditView());
1580 }
1581 #endif
1582
1583 int WeldEditView::GetSurroundingText(OUString& rSurrounding)
1584 {
1585     EditView* pEditView = GetEditView();
1586     if (!pEditView)
1587         return -1;
1588     rSurrounding = pEditView->GetSurroundingText();
1589     return pEditView->GetSurroundingTextSelection().Min();
1590 }
1591
1592 bool WeldEditView::DeleteSurroundingText(const Selection& rRange)
1593 {
1594     EditView* pEditView = GetEditView();
1595     if (!pEditView)
1596         return false;
1597     return pEditView->DeleteSurroundingText(rRange);
1598 }
1599
1600 void WeldEditView::GetFocus()
1601 {
1602     EditView* pEditView = GetEditView();
1603     if (pEditView)
1604     {
1605         pEditView->ShowCursor(false);
1606         Invalidate(); // redraw with cursor
1607     }
1608
1609     weld::CustomWidgetController::GetFocus();
1610
1611 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1612     if (m_xAccessible.is())
1613     {
1614         // Note: will implicitly send the AccessibleStateType::FOCUSED event
1615         ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper();
1616         if (pHelper)
1617             pHelper->SetFocus();
1618     }
1619 #endif
1620 }
1621
1622 void WeldEditView::LoseFocus()
1623 {
1624     weld::CustomWidgetController::LoseFocus();
1625     Invalidate(); // redraw without cursor
1626
1627 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1628     if (m_xAccessible.is())
1629     {
1630         // Note: will implicitly send the AccessibleStateType::FOCUSED event
1631         ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper();
1632         if (pHelper)
1633             pHelper->SetFocus(false);
1634     }
1635 #endif
1636 }
1637
1638 bool WeldEditView::CanFocus() const { return true; }
1639
1640 css::uno::Reference<css::datatransfer::dnd::XDropTarget> WeldEditView::GetDropTarget()
1641 {
1642     if (!m_xDropTarget)
1643         m_xDropTarget = weld::CustomWidgetController::GetDropTarget();
1644     return m_xDropTarget;
1645 }
1646
1647 css::uno::Reference<css::datatransfer::clipboard::XClipboard> WeldEditView::GetClipboard() const
1648 {
1649     return weld::CustomWidgetController::GetClipboard();
1650 }
1651
1652 namespace
1653 {
1654 class WeldEditViewUIObject final : public DrawingAreaUIObject
1655 {
1656 private:
1657     WeldEditView* mpEditView;
1658
1659 public:
1660     WeldEditViewUIObject(const VclPtr<vcl::Window>& rDrawingArea)
1661         : DrawingAreaUIObject(rDrawingArea)
1662         , mpEditView(static_cast<WeldEditView*>(mpController))
1663     {
1664     }
1665
1666     static std::unique_ptr<UIObject> create(vcl::Window* pWindow)
1667     {
1668         return std::unique_ptr<UIObject>(new WeldEditViewUIObject(pWindow));
1669     }
1670
1671     virtual StringMap get_state() override
1672     {
1673         StringMap aMap = WindowUIObject::get_state();
1674         aMap["Text"] = mpEditView->GetText();
1675         return aMap;
1676     }
1677
1678 private:
1679     virtual OUString get_name() const override { return "WeldEditViewUIObject"; }
1680 };
1681 }
1682
1683 FactoryFunction WeldEditView::GetUITestFactory() const { return WeldEditViewUIObject::create; }
1684
1685 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */