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