sc/source/ui/Accessibility/AccessibleText.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 <scitems.hxx>
  21 #include <editeng/eeitem.hxx>
  22
  23 #include <memory>
  24 #include <AccessibleText.hxx>
  25 #include <AccessibleCell.hxx>
  26 #include <attrib.hxx>
  27 #include <tabvwsh.hxx>
  28 #include <editutil.hxx>
  29 #include <document.hxx>
  30 #include <scmod.hxx>
  31 #include <prevwsh.hxx>
  32 #include <docsh.hxx>
  33 #include <prevloc.hxx>
  34 #include <patattr.hxx>
  35 #include <inputwin.hxx>
  36 #include <editeng/unofored.hxx>
  37 #include <editeng/editview.hxx>
  38 #include <editeng/unoedhlp.hxx>
  39 #include <editeng/fhgtitem.hxx>
  40 #include <editeng/adjustitem.hxx>
  41 #include <editeng/justifyitem.hxx>
  42 #include <svx/svdmodel.hxx>
  43 #include <svx/algitem.hxx>
  44 #include <vcl/svapp.hxx>
  45
  46 class ScViewForwarder : public SvxViewForwarder
  47 {
  48     ScTabViewShell*     mpViewShell;
  49     ScSplitPos          meSplitPos;
  50 public:
  51                         ScViewForwarder(ScTabViewShell* pViewShell, ScSplitPos eSplitPos);
  52
  53     virtual bool        IsValid() const override;
  54     virtual Point       LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const override;
  55     virtual Point       PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const override;
  56
  57     void                SetInvalid();
  58 };
  59
  60 ScViewForwarder::ScViewForwarder(ScTabViewShell* pViewShell, ScSplitPos eSplitPos)
  61     :
  62     mpViewShell(pViewShell),
  63     meSplitPos(eSplitPos)
  64 {
  65 }
  66
  67 bool ScViewForwarder::IsValid() const
  68 {
  69     return mpViewShell != nullptr;
  70 }
  71
  72 Point ScViewForwarder::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
  73 {
  74     if (mpViewShell)
  75     {
  76         vcl::Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos);
  77         if (pWindow)
  78             return pWindow->LogicToPixel( rPoint, rMapMode );
  79     }
  80     else
  81     {
  82         OSL_FAIL("this ViewForwarder is not valid");
  83     }
  84     return Point();
  85 }
  86
  87 Point ScViewForwarder::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
  88 {
  89     if (mpViewShell)
  90     {
  91         vcl::Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos);
  92         if (pWindow)
  93             return pWindow->PixelToLogic( rPoint, rMapMode );
  94     }
  95     else
  96     {
  97         OSL_FAIL("this ViewForwarder is not valid");
  98     }
  99     return Point();
 100 }
 101
 102 void ScViewForwarder::SetInvalid()
 103 {
 104     mpViewShell = nullptr;
 105 }
 106
 107 class ScEditObjectViewForwarder : public SvxViewForwarder
 108 {
 109     VclPtr<OutputDevice> mpWindow;
 110     // #i49561# EditView needed for access to its visible area.
 111     const EditView*     mpEditView;
 112 public:
 113                         ScEditObjectViewForwarder( OutputDevice* pWindow,
 114                                                    const EditView* _pEditView);
 115
 116     virtual bool        IsValid() const override;
 117     virtual Point       LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const override;
 118     virtual Point       PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const override;
 119
 120     void                SetInvalid();
 121 };
 122
 123 ScEditObjectViewForwarder::ScEditObjectViewForwarder( OutputDevice* pWindow,
 124                                                       const EditView* _pEditView )
 125     : mpWindow(pWindow)
 126     , mpEditView( _pEditView )
 127 {
 128 }
 129
 130 bool ScEditObjectViewForwarder::IsValid() const
 131 {
 132     return (mpWindow != nullptr);
 133 }
 134
 135 Point ScEditObjectViewForwarder::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
 136 {
 137     if (mpWindow)
 138     {
 139         // #i49561# - consider offset of the visible area
 140         // of the EditView before converting point to pixel.
 141         Point aPoint( rPoint );
 142         if ( mpEditView )
 143         {
 144             tools::Rectangle aEditViewVisArea( mpEditView->GetVisArea() );
 145             aPoint += aEditViewVisArea.TopLeft();
 146         }
 147         return mpWindow->LogicToPixel( aPoint, rMapMode );
 148     }
 149     else
 150     {
 151         OSL_FAIL("this ViewForwarder is not valid");
 152     }
 153     return Point();
 154 }
 155
 156 Point ScEditObjectViewForwarder::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
 157 {
 158     if (mpWindow)
 159     {
 160         // #i49561# - consider offset of the visible area
 161         // of the EditView after converting point to logic.
 162         Point aPoint( mpWindow->PixelToLogic( rPoint, rMapMode ) );
 163         if ( mpEditView )
 164         {
 165             tools::Rectangle aEditViewVisArea( mpEditView->GetVisArea() );
 166             aPoint -= aEditViewVisArea.TopLeft();
 167         }
 168         return aPoint;
 169     }
 170     else
 171     {
 172         OSL_FAIL("this ViewForwarder is not valid");
 173     }
 174     return Point();
 175 }
 176
 177 void ScEditObjectViewForwarder::SetInvalid()
 178 {
 179     mpWindow = nullptr;
 180 }
 181
 182 class ScPreviewViewForwarder : public SvxViewForwarder
 183 {
 184 protected:
 185     ScPreviewShell*     mpViewShell;
 186 public:
 187     explicit            ScPreviewViewForwarder(ScPreviewShell* pViewShell);
 188
 189     virtual bool        IsValid() const override;
 190     virtual Point       LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const override;
 191     virtual Point       PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const override;
 192
 193     void                SetInvalid();
 194 };
 195
 196 ScPreviewViewForwarder::ScPreviewViewForwarder(ScPreviewShell* pViewShell)
 197     : mpViewShell(pViewShell)
 198 {
 199 }
 200
 201 bool ScPreviewViewForwarder::IsValid() const
 202 {
 203     return mpViewShell != nullptr;
 204 }
 205
 206 Point ScPreviewViewForwarder::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
 207 {
 208     if (mpViewShell)
 209     {
 210         vcl::Window* pWindow = mpViewShell->GetWindow();
 211         if (pWindow)
 212         {
 213             MapMode aMapMode(pWindow->GetMapMode().GetMapUnit());
 214             Point aPoint2( OutputDevice::LogicToLogic( rPoint, rMapMode, aMapMode) );
 215             return pWindow->LogicToPixel(aPoint2);
 216         }
 217     }
 218     else
 219     {
 220         OSL_FAIL("this ViewForwarder is not valid");
 221     }
 222     return Point();
 223 }
 224
 225 Point ScPreviewViewForwarder::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
 226 {
 227     if (mpViewShell)
 228     {
 229         vcl::Window* pWindow = mpViewShell->GetWindow();
 230         if (pWindow)
 231         {
 232             MapMode aMapMode(pWindow->GetMapMode());
 233             aMapMode.SetOrigin(Point());
 234             Point aPoint1( pWindow->PixelToLogic( rPoint ) );
 235             Point aPoint2( OutputDevice::LogicToLogic( aPoint1,
 236                                                        MapMode(aMapMode.GetMapUnit()),
 237                                                        rMapMode ) );
 238             return aPoint2;
 239         }
 240     }
 241     else
 242     {
 243         OSL_FAIL("this ViewForwarder is not valid");
 244     }
 245     return Point();
 246 }
 247
 248 void ScPreviewViewForwarder::SetInvalid()
 249 {
 250     mpViewShell = nullptr;
 251 }
 252
 253 namespace {
 254
 255 class ScPreviewHeaderFooterViewForwarder : public ScPreviewViewForwarder
 256 {
 257 public:
 258                         ScPreviewHeaderFooterViewForwarder(ScPreviewShell* pViewShell);
 259 };
 260
 261 }
 262
 263 ScPreviewHeaderFooterViewForwarder::ScPreviewHeaderFooterViewForwarder(ScPreviewShell* pViewShell)
 264     :
 265     ScPreviewViewForwarder(pViewShell)
 266 {
 267 }
 268
 269 namespace {
 270
 271 class ScPreviewCellViewForwarder : public ScPreviewViewForwarder
 272 {
 273 public:
 274                         ScPreviewCellViewForwarder(ScPreviewShell* pViewShell);
 275 };
 276
 277 }
 278
 279 ScPreviewCellViewForwarder::ScPreviewCellViewForwarder(ScPreviewShell* pViewShell)
 280     :
 281     ScPreviewViewForwarder(pViewShell)
 282 {
 283 }
 284
 285 namespace {
 286
 287 class ScPreviewHeaderCellViewForwarder : public ScPreviewViewForwarder
 288 {
 289 public:
 290                         ScPreviewHeaderCellViewForwarder(ScPreviewShell* pViewShell);
 291 };
 292
 293 }
 294
 295 ScPreviewHeaderCellViewForwarder::ScPreviewHeaderCellViewForwarder(ScPreviewShell* pViewShell)
 296     :
 297     ScPreviewViewForwarder(pViewShell)
 298 {
 299 }
 300
 301 namespace {
 302
 303 class ScPreviewNoteViewForwarder : public ScPreviewViewForwarder
 304 {
 305 public:
 306                         ScPreviewNoteViewForwarder(ScPreviewShell* pViewShell);
 307 };
 308
 309 }
 310
 311 ScPreviewNoteViewForwarder::ScPreviewNoteViewForwarder(ScPreviewShell* pViewShell)
 312     :
 313     ScPreviewViewForwarder(pViewShell)
 314 {
 315 }
 316
 317 class ScEditViewForwarder : public SvxEditViewForwarder
 318 {
 319     EditView*           mpEditView;
 320     VclPtr<OutputDevice> mpWindow;
 321 public:
 322                         ScEditViewForwarder(EditView* pEditView, OutputDevice* pWin);
 323
 324     virtual bool        IsValid() const override;
 325     virtual Point       LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const override;
 326     virtual Point       PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const override;
 327     virtual bool        GetSelection( ESelection& rSelection ) const override;
 328     virtual bool        SetSelection( const ESelection& rSelection ) override;
 329     virtual bool        Copy() override;
 330     virtual bool        Cut() override;
 331     virtual bool        Paste() override;
 332
 333     void                SetInvalid();
 334 };
 335
 336 ScEditViewForwarder::ScEditViewForwarder(EditView* pEditView, OutputDevice* pWin)
 337     : mpEditView(pEditView)
 338     , mpWindow(pWin)
 339 {
 340 }
 341
 342 bool ScEditViewForwarder::IsValid() const
 343 {
 344     return mpWindow && mpEditView;
 345 }
 346
 347 Point ScEditViewForwarder::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
 348 {
 349     if (mpWindow)
 350         return mpWindow->LogicToPixel( rPoint, rMapMode );
 351     else
 352     {
 353         OSL_FAIL("this ViewForwarder is not valid");
 354     }
 355     return Point();
 356 }
 357
 358 Point ScEditViewForwarder::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
 359 {
 360     if (mpWindow)
 361         return mpWindow->PixelToLogic( rPoint, rMapMode );
 362     else
 363     {
 364         OSL_FAIL("this ViewForwarder is not valid");
 365     }
 366     return Point();
 367 }
 368
 369 bool ScEditViewForwarder::GetSelection( ESelection& rSelection ) const
 370 {
 371     bool bResult(false);
 372     if (IsValid())
 373     {
 374         rSelection = mpEditView->GetSelection();
 375         bResult = true;
 376     }
 377     else
 378     {
 379         OSL_FAIL("this ViewForwarder is not valid");
 380     }
 381     return bResult;
 382 }
 383
 384 bool ScEditViewForwarder::SetSelection( const ESelection& rSelection )
 385 {
 386     bool bResult(false);
 387     if (IsValid())
 388     {
 389         mpEditView->SetSelection(rSelection);
 390         bResult = true;
 391     }
 392     else
 393     {
 394         OSL_FAIL("this ViewForwarder is not valid");
 395     }
 396     return bResult;
 397 }
 398
 399 bool ScEditViewForwarder::Copy()
 400 {
 401     bool bResult(false);
 402     if (IsValid())
 403     {
 404         mpEditView->Copy();
 405         bResult = true;
 406     }
 407     else
 408     {
 409         OSL_FAIL("this ViewForwarder is not valid");
 410     }
 411     return bResult;
 412 }
 413
 414 bool ScEditViewForwarder::Cut()
 415 {
 416     bool bResult(false);
 417     if (IsValid())
 418     {
 419         mpEditView->Cut();
 420         bResult = true;
 421     }
 422     else
 423     {
 424         OSL_FAIL("this ViewForwarder is not valid");
 425     }
 426     return bResult;
 427 }
 428
 429 bool ScEditViewForwarder::Paste()
 430 {
 431     bool bResult(false);
 432     if (IsValid())
 433     {
 434         mpEditView->Paste();
 435         bResult = true;
 436     }
 437     else
 438     {
 439         OSL_FAIL("this ViewForwarder is not valid");
 440     }
 441     return bResult;
 442 }
 443
 444 void ScEditViewForwarder::SetInvalid()
 445 {
 446     mpWindow = nullptr;
 447     mpEditView = nullptr;
 448 }
 449
 450 //  ScAccessibleCellTextData: shared data between sub objects of an accessible cell text object
 451
 452 ScAccessibleCellTextData::ScAccessibleCellTextData(ScTabViewShell* pViewShell,
 453         const ScAddress& rP, ScSplitPos eSplitPos, ScAccessibleCell* pAccCell)
 454     : ScAccessibleCellBaseTextData(GetDocShell(pViewShell), rP),
 455     mpViewShell(pViewShell),
 456     meSplitPos(eSplitPos),
 457     mpAccessibleCell( pAccCell )
 458 {
 459 }
 460
 461 ScAccessibleCellTextData::~ScAccessibleCellTextData()
 462 {
 463     if (pEditEngine)
 464         pEditEngine->SetNotifyHdl(Link<EENotify&,void>());
 465     mpViewForwarder.reset();
 466 }
 467
 468 void ScAccessibleCellTextData::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 469 {
 470     if ( rHint.GetId() == SfxHintId::Dying )
 471     {
 472         mpViewShell = nullptr;                     // invalid now
 473         if (mpViewForwarder)
 474             mpViewForwarder->SetInvalid();
 475     }
 476     ScAccessibleCellBaseTextData::Notify(rBC, rHint);
 477 }
 478
 479 ScAccessibleTextData* ScAccessibleCellTextData::Clone() const
 480 {
 481     return new ScAccessibleCellTextData( mpViewShell, aCellPos, meSplitPos, mpAccessibleCell );
 482 }
 483
 484 SvxTextForwarder* ScAccessibleCellTextData::GetTextForwarder()
 485 {
 486     ScCellTextData::GetTextForwarder(); // creates Forwarder and EditEngine
 487
 488     if ( pDocShell && pEditEngine && mpViewShell )
 489     {
 490         ScDocument& rDoc = pDocShell->GetDocument();
 491         tools::Long nSizeX, nSizeY;
 492         mpViewShell->GetViewData().GetMergeSizePixel(
 493             aCellPos.Col(), aCellPos.Row(), nSizeX, nSizeY);
 494
 495         Size aSize(nSizeX, nSizeY);
 496
 497         // #i92143# text getRangeExtents reports incorrect 'x' values for spreadsheet cells
 498         tools::Long nIndent = 0;
 499         const SvxHorJustifyItem* pHorJustifyItem = rDoc.GetAttr( aCellPos, ATTR_HOR_JUSTIFY );
 500         SvxCellHorJustify eHorJust = pHorJustifyItem ? pHorJustifyItem->GetValue() : SvxCellHorJustify::Standard;
 501         if ( eHorJust == SvxCellHorJustify::Left )
 502         {
 503             const ScIndentItem* pIndentItem = rDoc.GetAttr( aCellPos, ATTR_INDENT );
 504             if ( pIndentItem )
 505             {
 506                 nIndent = static_cast< tools::Long >( pIndentItem->GetValue() );
 507             }
 508         }
 509
 510         const SvxMarginItem* pMarginItem = rDoc.GetAttr( aCellPos, ATTR_MARGIN );
 511         ScViewData& rViewData = mpViewShell->GetViewData();
 512         double nPPTX = rViewData.GetPPTX();
 513         double nPPTY = rViewData.GetPPTY();
 514         tools::Long nLeftM = ( pMarginItem ? static_cast< tools::Long >( ( pMarginItem->GetLeftMargin() + nIndent ) * nPPTX ) : 0 );
 515         tools::Long nTopM = ( pMarginItem ? static_cast< tools::Long >( pMarginItem->GetTopMargin() * nPPTY ) : 0 );
 516         tools::Long nRightM = ( pMarginItem ? static_cast< tools::Long >( pMarginItem->GetRightMargin() * nPPTX ) : 0 );
 517         tools::Long nBottomM = ( pMarginItem ? static_cast< tools::Long >( pMarginItem->GetBottomMargin() * nPPTY ) : 0 );
 518         tools::Long nWidth = aSize.getWidth() - nLeftM - nRightM;
 519         aSize.setWidth( nWidth );
 520         aSize.setHeight( aSize.getHeight() - nTopM - nBottomM );
 521
 522         vcl::Window* pWin = mpViewShell->GetWindowByPos( meSplitPos );
 523         if ( pWin )
 524         {
 525             aSize = pWin->PixelToLogic( aSize, pEditEngine->GetRefMapMode() );
 526         }
 527
 528         /*  #i19430# Gnopernicus reads text partly if it sticks out of the cell
 529             boundaries. This leads to wrong results in cases where the cell text
 530             is rotated, because rotation is not taken into account when calcu-
 531             lating the visible part of the text. In these cases we will expand
 532             the cell size passed as paper size to the edit engine. The function
 533             accessibility::AccessibleStaticTextBase::GetParagraphBoundingBox()
 534             (see svx/source/accessibility/AccessibleStaticTextBase.cxx) will
 535             return the size of the complete text then, which is used to expand
 536             the cell bounding box in ScAccessibleCell::GetBoundingBox()
 537             (see sc/source/ui/Accessibility/AccessibleCell.cxx). */
 538         const ScRotateValueItem* pItem = rDoc.GetAttr( aCellPos, ATTR_ROTATE_VALUE );
 539         if( pItem && (pItem->GetValue() != 0) )
 540         {
 541             pEditEngine->SetPaperSize( Size( LONG_MAX, aSize.getHeight() ) );
 542             tools::Long nTxtWidth = static_cast< tools::Long >( pEditEngine->CalcTextWidth() );
 543             aSize.setWidth( std::max( aSize.getWidth(), nTxtWidth + 2 ) );
 544         }
 545         else
 546         {
 547             // #i92143# text getRangeExtents reports incorrect 'x' values for spreadsheet cells
 548             const ScLineBreakCell* pLineBreakItem = rDoc.GetAttr( aCellPos, ATTR_LINEBREAK );
 549             bool bLineBreak = ( pLineBreakItem && pLineBreakItem->GetValue() );
 550             if ( !bLineBreak )
 551             {
 552                 tools::Long nTxtWidth = static_cast< tools::Long >( pEditEngine->CalcTextWidth() );
 553                 aSize.setWidth( ::std::max( aSize.getWidth(), nTxtWidth ) );
 554             }
 555         }
 556
 557         pEditEngine->SetPaperSize( aSize );
 558
 559         // #i92143# text getRangeExtents reports incorrect 'x' values for spreadsheet cells
 560         if ( eHorJust == SvxCellHorJustify::Standard && rDoc.HasValueData( aCellPos.Col(), aCellPos.Row(), aCellPos.Tab() ) )
 561         {
 562             pEditEngine->SetDefaultItem( SvxAdjustItem( SvxAdjust::Right, EE_PARA_JUST ) );
 563         }
 564
 565         Size aTextSize;
 566         if ( pWin )
 567         {
 568             aTextSize = pWin->LogicToPixel( Size( pEditEngine->CalcTextWidth(), pEditEngine->GetTextHeight() ), pEditEngine->GetRefMapMode() );
 569         }
 570         tools::Long nTextWidth = aTextSize.Width();
 571         tools::Long nTextHeight = aTextSize.Height();
 572
 573         tools::Long nOffsetX = nLeftM;
 574         tools::Long nDiffX = nTextWidth - nWidth;
 575         if ( nDiffX > 0 )
 576         {
 577             switch ( eHorJust )
 578             {
 579                 case SvxCellHorJustify::Right:
 580                     {
 581                         nOffsetX -= nDiffX;
 582                     }
 583                     break;
 584                 case SvxCellHorJustify::Center:
 585                     {
 586                         nOffsetX -= nDiffX / 2;
 587                     }
 588                     break;
 589                 default:
 590                     {
 591                     }
 592                     break;
 593             }
 594         }
 595
 596         tools::Long nOffsetY = 0;
 597         const SvxVerJustifyItem* pVerJustifyItem = rDoc.GetAttr( aCellPos, ATTR_VER_JUSTIFY );
 598         SvxCellVerJustify eVerJust = ( pVerJustifyItem ? pVerJustifyItem->GetValue() : SvxCellVerJustify::Standard );
 599         switch ( eVerJust )
 600         {
 601             case SvxCellVerJustify::Standard:
 602             case SvxCellVerJustify::Bottom:
 603                 {
 604                     nOffsetY = nSizeY - nBottomM - nTextHeight;
 605                 }
 606                 break;
 607             case SvxCellVerJustify::Center:
 608                 {
 609                     nOffsetY = ( nSizeY - nTopM - nBottomM - nTextHeight ) / 2 + nTopM;
 610                 }
 611                 break;
 612             default:
 613                 {
 614                     nOffsetY = nTopM;
 615                 }
 616                 break;
 617         }
 618
 619         if ( mpAccessibleCell )
 620         {
 621             mpAccessibleCell->SetOffset( Point( nOffsetX, nOffsetY ) );
 622         }
 623
 624         pEditEngine->SetNotifyHdl( LINK(this, ScAccessibleCellTextData, NotifyHdl) );
 625     }
 626
 627     return pForwarder.get();
 628 }
 629
 630 SvxViewForwarder* ScAccessibleCellTextData::GetViewForwarder()
 631 {
 632     if (!mpViewForwarder)
 633         mpViewForwarder.reset(new ScViewForwarder(mpViewShell, meSplitPos));
 634     return mpViewForwarder.get();
 635 }
 636
 637 SvxEditViewForwarder* ScAccessibleCellTextData::GetEditViewForwarder( bool /* bCreate */ )
 638 {
 639     //#102219#; there should no EditViewForwarder be, because the cell is now readonly in this interface
 640     return nullptr;
 641 }
 642
 643 IMPL_LINK(ScAccessibleTextData, NotifyHdl, EENotify&, aNotify, void)
 644 {
 645     ::std::unique_ptr< SfxHint > aHint = SvxEditSourceHelper::EENotification2Hint( &aNotify );
 646
 647     if (aHint)
 648         GetBroadcaster().Broadcast(*aHint);
 649 }
 650
 651 ScDocShell* ScAccessibleCellTextData::GetDocShell(ScTabViewShell* pViewShell)
 652 {
 653     ScDocShell* pDocSh = nullptr;
 654     if (pViewShell)
 655         pDocSh = pViewShell->GetViewData().GetDocShell();
 656     return pDocSh;
 657 }
 658
 659 ScAccessibleEditObjectTextData::ScAccessibleEditObjectTextData(EditView* pEditView, OutputDevice* pWin, bool isClone)
 660     :
 661     mpEditView(pEditView),
 662     mpEditEngine(pEditView ? pEditView->GetEditEngine() : nullptr),
 663     mpWindow(pWin)
 664 {
 665     // If the object is cloned, do NOT add notify hdl.
 666     mbIsCloned = isClone;
 667     if (mpEditEngine && !mbIsCloned)
 668         mpEditEngine->SetNotifyHdl( LINK(this, ScAccessibleEditObjectTextData, NotifyHdl) );
 669 }
 670
 671 ScAccessibleEditObjectTextData::~ScAccessibleEditObjectTextData()
 672 {
 673     // If the object is cloned, do NOT set notify hdl.
 674     if (mpEditEngine && !mbIsCloned)
 675         mpEditEngine->SetNotifyHdl(Link<EENotify&,void>());
 676     mpViewForwarder.reset();
 677     mpEditViewForwarder.reset();
 678     mpForwarder.reset();
 679 }
 680
 681 void ScAccessibleEditObjectTextData::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 682 {
 683     if ( rHint.GetId() == SfxHintId::Dying )
 684     {
 685         mpWindow = nullptr;
 686         mpEditView = nullptr;
 687         mpEditEngine = nullptr;
 688         mpForwarder.reset();
 689         if (mpViewForwarder)
 690             mpViewForwarder->SetInvalid();
 691         if (mpEditViewForwarder)
 692             mpEditViewForwarder->SetInvalid();
 693     }
 694     ScAccessibleTextData::Notify(rBC, rHint);
 695 }
 696
 697 ScAccessibleTextData* ScAccessibleEditObjectTextData::Clone() const
 698 {
 699     // Add para to indicate the object is cloned
 700     return new ScAccessibleEditObjectTextData(mpEditView, mpWindow, true);
 701 }
 702
 703 SvxTextForwarder* ScAccessibleEditObjectTextData::GetTextForwarder()
 704 {
 705     if ((!mpForwarder && mpEditView) || (mpEditEngine && !mpEditEngine->GetNotifyHdl().IsSet()))
 706     {
 707         if (!mpEditEngine)
 708             mpEditEngine = mpEditView->GetEditEngine();
 709         // If the object is cloned, do NOT add notify hdl.
 710         if (mpEditEngine && !mpEditEngine->GetNotifyHdl().IsSet()&&!mbIsCloned)
 711             mpEditEngine->SetNotifyHdl( LINK(this, ScAccessibleEditObjectTextData, NotifyHdl) );
 712         if(!mpForwarder)
 713             mpForwarder.reset(new SvxEditEngineForwarder(*mpEditEngine));
 714     }
 715     return mpForwarder.get();
 716 }
 717
 718 SvxViewForwarder* ScAccessibleEditObjectTextData::GetViewForwarder()
 719 {
 720     if (!mpViewForwarder)
 721     {
 722         // i#49561 Get right-aligned cell content to be read by screenreader.
 723         mpViewForwarder.reset(new ScEditObjectViewForwarder( mpWindow, mpEditView ));
 724     }
 725     return mpViewForwarder.get();
 726 }
 727
 728 SvxEditViewForwarder* ScAccessibleEditObjectTextData::GetEditViewForwarder( bool bCreate )
 729 {
 730     if (!mpEditViewForwarder && mpEditView)
 731         mpEditViewForwarder.reset(new ScEditViewForwarder(mpEditView, mpWindow));
 732     if (bCreate)
 733     {
 734         if (!mpEditView && mpEditViewForwarder)
 735         {
 736             mpEditViewForwarder.reset();
 737         }
 738     }
 739     return mpEditViewForwarder.get();
 740 }
 741
 742 IMPL_LINK(ScAccessibleEditObjectTextData, NotifyHdl, EENotify&, rNotify, void)
 743 {
 744     ::std::unique_ptr< SfxHint > aHint = SvxEditSourceHelper::EENotification2Hint( &rNotify );
 745
 746     if (aHint)
 747         GetBroadcaster().Broadcast(*aHint);
 748 }
 749
 750 ScAccessibleEditLineTextData::ScAccessibleEditLineTextData(EditView* pEditView,
 751                                                            OutputDevice* pWin,
 752                                                            ScTextWnd* pTxtWnd)
 753     : ScAccessibleEditObjectTextData(pEditView, pWin)
 754     , mpTxtWnd(pTxtWnd)
 755     , mbEditEngineCreated(false)
 756 {
 757     if (mpTxtWnd)
 758         mpTxtWnd->InsertAccessibleTextData( *this );
 759 }
 760
 761 ScAccessibleEditLineTextData::~ScAccessibleEditLineTextData()
 762 {
 763     if (mpTxtWnd)
 764         mpTxtWnd->RemoveAccessibleTextData( *this );
 765
 766     if (mbEditEngineCreated && mpEditEngine)
 767     {
 768         delete mpEditEngine;
 769         mpEditEngine = nullptr;    // don't access in ScAccessibleEditObjectTextData dtor!
 770     }
 771     else if (mpTxtWnd && mpTxtWnd->HasEditView() && mpTxtWnd->GetEditView()->GetEditEngine())
 772     {
 773         //  the NotifyHdl also has to be removed from the ScTextWnd's EditEngine
 774         //  (it's set in ScAccessibleEditLineTextData::GetTextForwarder, and mpEditEngine
 775         //  is reset there)
 776         mpTxtWnd->GetEditView()->GetEditEngine()->SetNotifyHdl(Link<EENotify&,void>());
 777     }
 778 }
 779
 780 void ScAccessibleEditLineTextData::Dispose()
 781 {
 782     if (mpTxtWnd)
 783         mpTxtWnd->RemoveAccessibleTextData( *this );
 784
 785     ResetEditMode();
 786     mpWindow = nullptr;
 787     mpTxtWnd = nullptr;
 788 }
 789
 790 ScAccessibleTextData* ScAccessibleEditLineTextData::Clone() const
 791 {
 792     return new ScAccessibleEditLineTextData(mpEditView, mpWindow, mpTxtWnd);
 793 }
 794
 795 SvxTextForwarder* ScAccessibleEditLineTextData::GetTextForwarder()
 796 {
 797     if (mpTxtWnd)
 798     {
 799         if (mpTxtWnd->HasEditView())
 800         {
 801             mpEditView = mpTxtWnd->GetEditView();
 802
 803             if (mbEditEngineCreated && mpEditEngine)
 804                 ResetEditMode();
 805             mbEditEngineCreated = false;
 806
 807             mpEditView = mpTxtWnd->GetEditView();
 808             ScAccessibleEditObjectTextData::GetTextForwarder(); // fill the mpForwarder
 809             mpEditEngine = nullptr;
 810         }
 811         else
 812         {
 813             mpEditView = nullptr;
 814
 815             if (mpEditEngine && !mbEditEngineCreated)
 816                 ResetEditMode();
 817             if (!mpEditEngine)
 818             {
 819                 SfxItemPool* pEnginePool = EditEngine::CreatePool();
 820                 pEnginePool->FreezeIdRanges();
 821                 mpEditEngine = new ScFieldEditEngine(nullptr, pEnginePool, nullptr, true);
 822                 mbEditEngineCreated = true;
 823                 mpEditEngine->EnableUndo( false );
 824                 mpEditEngine->SetRefMapMode(MapMode(MapUnit::Map100thMM));
 825                 mpForwarder.reset(new SvxEditEngineForwarder(*mpEditEngine));
 826
 827                 mpEditEngine->SetText(mpTxtWnd->GetTextString());
 828
 829 #if 0
 830                 Size aSize(pTxtWnd->GetSizePixel());
 831                 aSize = pTxtWnd->PixelToLogic(aSize, mpEditEngine->GetRefMapMode());
 832                 mpEditEngine->SetPaperSize(aSize);
 833 #else
 834                 OutputDevice& rDevice = mpTxtWnd->GetDrawingArea()->get_ref_device();
 835                 Size aSize(rDevice.GetOutputSizePixel());
 836                 aSize = rDevice.PixelToLogic(aSize, mpEditEngine->GetRefMapMode());
 837                 mpEditEngine->SetPaperSize(aSize);
 838 #endif
 839
 840                 mpEditEngine->SetNotifyHdl( LINK(this, ScAccessibleEditObjectTextData, NotifyHdl) );
 841             }
 842         }
 843     }
 844     return mpForwarder.get();
 845 }
 846
 847 SvxEditViewForwarder* ScAccessibleEditLineTextData::GetEditViewForwarder( bool bCreate )
 848 {
 849     if (mpTxtWnd)
 850     {
 851         if (!mpTxtWnd->HasEditView() && bCreate)
 852         {
 853             if ( !mpTxtWnd->IsInputActive() )
 854             {
 855                 mpTxtWnd->StartEditEngine();
 856                 mpTxtWnd->GrabFocus();
 857
 858                 mpEditView = mpTxtWnd->GetEditView();
 859             }
 860         }
 861     }
 862
 863     return ScAccessibleEditObjectTextData::GetEditViewForwarder(bCreate);
 864 }
 865
 866 void ScAccessibleEditLineTextData::ResetEditMode()
 867 {
 868     if (mbEditEngineCreated && mpEditEngine)
 869         delete mpEditEngine;
 870     else if (mpTxtWnd && mpTxtWnd->HasEditView() && mpTxtWnd->GetEditView()->GetEditEngine())
 871         mpTxtWnd->GetEditView()->GetEditEngine()->SetNotifyHdl(Link<EENotify&,void>());
 872     mpEditEngine = nullptr;
 873
 874     mpForwarder.reset();
 875     mpEditViewForwarder.reset();
 876     mpViewForwarder.reset();
 877     mbEditEngineCreated = false;
 878 }
 879
 880 void ScAccessibleEditLineTextData::TextChanged()
 881 {
 882     if (mbEditEngineCreated && mpEditEngine)
 883     {
 884         if (mpTxtWnd)
 885             mpEditEngine->SetText(mpTxtWnd->GetTextString());
 886     }
 887 }
 888
 889 void ScAccessibleEditLineTextData::StartEdit()
 890 {
 891     ResetEditMode();
 892     mpEditView = nullptr;
 893
 894     // send SdrHintKind::BeginEdit
 895     SdrHint aHint(SdrHintKind::BeginEdit);
 896     GetBroadcaster().Broadcast( aHint );
 897 }
 898
 899 void ScAccessibleEditLineTextData::EndEdit()
 900 {
 901     // send SdrHintKind::EndEdit
 902     SdrHint aHint(SdrHintKind::EndEdit);
 903     GetBroadcaster().Broadcast( aHint );
 904
 905     ResetEditMode();
 906     mpEditView = nullptr;
 907 }
 908
 909 //  ScAccessiblePreviewCellTextData: shared data between sub objects of an accessible cell text object
 910
 911 ScAccessiblePreviewCellTextData::ScAccessiblePreviewCellTextData(ScPreviewShell* pViewShell,
 912                             const ScAddress& rP)
 913     : ScAccessibleCellBaseTextData(GetDocShell(pViewShell), rP),
 914     mpViewShell(pViewShell)
 915 {
 916 }
 917
 918 ScAccessiblePreviewCellTextData::~ScAccessiblePreviewCellTextData()
 919 {
 920     if (pEditEngine)
 921         pEditEngine->SetNotifyHdl(Link<EENotify&,void>());
 922     mpViewForwarder.reset();
 923 }
 924
 925 void ScAccessiblePreviewCellTextData::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 926 {
 927     if ( rHint.GetId() == SfxHintId::Dying )
 928     {
 929         mpViewShell = nullptr;                     // invalid now
 930         if (mpViewForwarder)
 931             mpViewForwarder->SetInvalid();
 932     }
 933     ScAccessibleCellBaseTextData::Notify(rBC, rHint);
 934 }
 935
 936 ScAccessibleTextData* ScAccessiblePreviewCellTextData::Clone() const
 937 {
 938     return new ScAccessiblePreviewCellTextData(mpViewShell, aCellPos);
 939 }
 940
 941 SvxTextForwarder* ScAccessiblePreviewCellTextData::GetTextForwarder()
 942 {
 943     bool bEditEngineBefore(pEditEngine != nullptr);
 944
 945     ScCellTextData::GetTextForwarder(); // creates Forwarder and EditEngine
 946
 947     if (!bEditEngineBefore && pEditEngine)
 948     {
 949         Size aSize(mpViewShell->GetLocationData().GetCellOutputRect(aCellPos).GetSize());
 950         vcl::Window* pWin = mpViewShell->GetWindow();
 951         if (pWin)
 952             aSize = pWin->PixelToLogic(aSize, pEditEngine->GetRefMapMode());
 953         pEditEngine->SetPaperSize(aSize);
 954     }
 955
 956     if (pEditEngine)
 957         pEditEngine->SetNotifyHdl( LINK(this, ScAccessiblePreviewCellTextData, NotifyHdl) );
 958
 959     return pForwarder.get();
 960 }
 961
 962 SvxViewForwarder* ScAccessiblePreviewCellTextData::GetViewForwarder()
 963 {
 964     if (!mpViewForwarder)
 965         mpViewForwarder.reset(new ScPreviewCellViewForwarder(mpViewShell));
 966     return mpViewForwarder.get();
 967 }
 968
 969 ScDocShell* ScAccessiblePreviewCellTextData::GetDocShell(ScPreviewShell* pViewShell)
 970 {
 971     ScDocShell* pDocSh = nullptr;
 972     if (pViewShell)
 973         pDocSh = static_cast<ScDocShell*>( pViewShell->GetDocument().GetDocumentShell());
 974     return pDocSh;
 975 }
 976
 977 //  ScAccessiblePreviewHeaderCellTextData: shared data between sub objects of an accessible cell text object
 978
 979 ScAccessiblePreviewHeaderCellTextData::ScAccessiblePreviewHeaderCellTextData(ScPreviewShell* pViewShell,
 980             const OUString& rText, const ScAddress& rP, bool bColHeader, bool bRowHeader)
 981     : ScAccessibleCellBaseTextData(GetDocShell(pViewShell), rP),
 982     mpViewShell(pViewShell),
 983     maText(rText),
 984     mbColHeader(bColHeader),
 985     mbRowHeader(bRowHeader)
 986 {
 987 }
 988
 989 ScAccessiblePreviewHeaderCellTextData::~ScAccessiblePreviewHeaderCellTextData()
 990 {
 991     if (pEditEngine)
 992         pEditEngine->SetNotifyHdl(Link<EENotify&,void>());
 993     mpViewForwarder.reset();
 994 }
 995
 996 void ScAccessiblePreviewHeaderCellTextData::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 997 {
 998     if ( rHint.GetId() == SfxHintId::Dying )
 999     {
1000         mpViewShell = nullptr;                     // invalid now
1001         if (mpViewForwarder)
1002             mpViewForwarder->SetInvalid();
1003     }
1004     ScAccessibleCellBaseTextData::Notify(rBC, rHint);
1005 }
1006
1007 ScAccessibleTextData* ScAccessiblePreviewHeaderCellTextData::Clone() const
1008 {
1009     return new ScAccessiblePreviewHeaderCellTextData(mpViewShell, maText, aCellPos, mbColHeader, mbRowHeader);
1010 }
1011
1012 SvxTextForwarder* ScAccessiblePreviewHeaderCellTextData::GetTextForwarder()
1013 {
1014     if (!pEditEngine)
1015     {
1016         if ( pDocShell )
1017         {
1018             ScDocument& rDoc = pDocShell->GetDocument();
1019             pEditEngine = rDoc.CreateFieldEditEngine();
1020         }
1021         else
1022         {
1023             SfxItemPool* pEnginePool = EditEngine::CreatePool();
1024             pEnginePool->FreezeIdRanges();
1025             pEditEngine.reset( new ScFieldEditEngine(nullptr, pEnginePool, nullptr, true) );
1026         }
1027         pEditEngine->EnableUndo( false );
1028         if (pDocShell)
1029             pEditEngine->SetRefDevice(pDocShell->GetRefDevice());
1030         else
1031             pEditEngine->SetRefMapMode(MapMode(MapUnit::Map100thMM));
1032         pForwarder.reset( new SvxEditEngineForwarder(*pEditEngine) );
1033     }
1034
1035     if (bDataValid)
1036         return pForwarder.get();
1037
1038     if (!maText.isEmpty())
1039     {
1040         if ( mpViewShell  )
1041         {
1042             Size aOutputSize;
1043             vcl::Window* pWindow = mpViewShell->GetWindow();
1044             if ( pWindow )
1045                 aOutputSize = pWindow->GetOutputSizePixel();
1046             tools::Rectangle aVisRect( Point(), aOutputSize );
1047             Size aSize(mpViewShell->GetLocationData().GetHeaderCellOutputRect(aVisRect, aCellPos, mbColHeader).GetSize());
1048             if (pWindow)
1049                 aSize = pWindow->PixelToLogic(aSize, pEditEngine->GetRefMapMode());
1050             pEditEngine->SetPaperSize(aSize);
1051         }
1052         pEditEngine->SetTextCurrentDefaults( maText );
1053     }
1054
1055     bDataValid = true;
1056
1057     pEditEngine->SetNotifyHdl( LINK(this, ScAccessiblePreviewHeaderCellTextData, NotifyHdl) );
1058
1059     return pForwarder.get();
1060 }
1061
1062 SvxViewForwarder* ScAccessiblePreviewHeaderCellTextData::GetViewForwarder()
1063 {
1064     if (!mpViewForwarder)
1065         mpViewForwarder.reset(new ScPreviewHeaderCellViewForwarder(mpViewShell));
1066     return mpViewForwarder.get();
1067 }
1068
1069 ScDocShell* ScAccessiblePreviewHeaderCellTextData::GetDocShell(ScPreviewShell* pViewShell)
1070 {
1071     ScDocShell* pDocSh = nullptr;
1072     if (pViewShell)
1073         pDocSh = static_cast<ScDocShell*>(pViewShell->GetDocument().GetDocumentShell());
1074     return pDocSh;
1075 }
1076
1077 ScAccessibleHeaderTextData::ScAccessibleHeaderTextData(ScPreviewShell* pViewShell,
1078                             const EditTextObject* pEditObj, SvxAdjust eAdjust)
1079     :
1080     mpViewForwarder(nullptr),
1081     mpViewShell(pViewShell),
1082     mpDocSh(nullptr),
1083     mpEditObj(pEditObj),
1084     mbDataValid(false),
1085     meAdjust(eAdjust)
1086 {
1087     if (pViewShell)
1088         mpDocSh = static_cast<ScDocShell*>(pViewShell->GetDocument().GetDocumentShell());
1089     if (mpDocSh)
1090         mpDocSh->GetDocument().AddUnoObject(*this);
1091 }
1092
1093 ScAccessibleHeaderTextData::~ScAccessibleHeaderTextData()
1094 {
1095     SolarMutexGuard aGuard;     //  needed for EditEngine dtor
1096
1097     if (mpDocSh)
1098         mpDocSh->GetDocument().RemoveUnoObject(*this);
1099     if (mpEditEngine)
1100         mpEditEngine->SetNotifyHdl(Link<EENotify&,void>());
1101     mpEditEngine.reset();
1102     mpForwarder.reset();
1103 }
1104
1105 ScAccessibleTextData* ScAccessibleHeaderTextData::Clone() const
1106 {
1107     return new ScAccessibleHeaderTextData(mpViewShell, mpEditObj, meAdjust);
1108 }
1109
1110 void ScAccessibleHeaderTextData::Notify( SfxBroadcaster&, const SfxHint& rHint )
1111 {
1112     if ( rHint.GetId() == SfxHintId::Dying )
1113     {
1114         mpViewShell = nullptr;// invalid now
1115         mpDocSh = nullptr;
1116         if (mpViewForwarder)
1117             mpViewForwarder->SetInvalid();
1118     }
1119 }
1120
1121 SvxTextForwarder* ScAccessibleHeaderTextData::GetTextForwarder()
1122 {
1123     if (!mpEditEngine)
1124     {
1125         SfxItemPool* pEnginePool = EditEngine::CreatePool();
1126         pEnginePool->FreezeIdRanges();
1127         std::unique_ptr<ScHeaderEditEngine> pHdrEngine(new ScHeaderEditEngine( pEnginePool ));
1128
1129         pHdrEngine->EnableUndo( false );
1130         pHdrEngine->SetRefMapMode(MapMode(MapUnit::MapTwip));
1131
1132         //  default font must be set, independently of document
1133         //  -> use global pool from module
1134
1135         SfxItemSet aDefaults( pHdrEngine->GetEmptyItemSet() );
1136         const ScPatternAttr& rPattern = SC_MOD()->GetPool().GetDefaultItem(ATTR_PATTERN);
1137         rPattern.FillEditItemSet( &aDefaults );
1138         //  FillEditItemSet adjusts font height to 1/100th mm,
1139         //  but for header/footer twips is needed, as in the PatternAttr:
1140         aDefaults.Put( rPattern.GetItem(ATTR_FONT_HEIGHT).CloneSetWhich(EE_CHAR_FONTHEIGHT) );
1141         aDefaults.Put( rPattern.GetItem(ATTR_CJK_FONT_HEIGHT).CloneSetWhich(EE_CHAR_FONTHEIGHT_CJK) );
1142         aDefaults.Put( rPattern.GetItem(ATTR_CTL_FONT_HEIGHT).CloneSetWhich(EE_CHAR_FONTHEIGHT_CTL) );
1143         aDefaults.Put( SvxAdjustItem( meAdjust, EE_PARA_JUST ) );
1144         pHdrEngine->SetDefaults( aDefaults );
1145
1146         ScHeaderFieldData aData;
1147         if (mpViewShell)
1148             mpViewShell->FillFieldData(aData);
1149         else
1150             ScHeaderFooterTextObj::FillDummyFieldData( aData );
1151         pHdrEngine->SetData( aData );
1152
1153         mpEditEngine = std::move(pHdrEngine);
1154         mpForwarder.reset(new SvxEditEngineForwarder(*mpEditEngine));
1155     }
1156
1157     if (mbDataValid)
1158         return mpForwarder.get();
1159
1160     if ( mpViewShell  )
1161     {
1162         tools::Rectangle aVisRect;
1163         mpViewShell->GetLocationData().GetHeaderPosition(aVisRect);
1164         Size aSize(aVisRect.GetSize());
1165         vcl::Window* pWin = mpViewShell->GetWindow();
1166         if (pWin)
1167             aSize = pWin->PixelToLogic(aSize, mpEditEngine->GetRefMapMode());
1168         mpEditEngine->SetPaperSize(aSize);
1169     }
1170     if (mpEditObj)
1171         mpEditEngine->SetTextCurrentDefaults(*mpEditObj);
1172
1173     mbDataValid = true;
1174     return mpForwarder.get();
1175 }
1176
1177 SvxViewForwarder* ScAccessibleHeaderTextData::GetViewForwarder()
1178 {
1179     if (!mpViewForwarder)
1180         mpViewForwarder = new ScPreviewHeaderFooterViewForwarder(mpViewShell);
1181     return mpViewForwarder;
1182 }
1183
1184 ScAccessibleNoteTextData::ScAccessibleNoteTextData(ScPreviewShell* pViewShell,
1185                             const OUString& sText, const ScAddress& aCellPos, bool bMarkNote)
1186     :
1187     mpViewForwarder(nullptr),
1188     mpViewShell(pViewShell),
1189     mpDocSh(nullptr),
1190     msText(sText),
1191     maCellPos(aCellPos),
1192     mbMarkNote(bMarkNote),
1193     mbDataValid(false)
1194 {
1195     if (pViewShell)
1196         mpDocSh = static_cast<ScDocShell*>(pViewShell->GetDocument().GetDocumentShell());
1197     if (mpDocSh)
1198         mpDocSh->GetDocument().AddUnoObject(*this);
1199 }
1200
1201 ScAccessibleNoteTextData::~ScAccessibleNoteTextData()
1202 {
1203     SolarMutexGuard aGuard;     //  needed for EditEngine dtor
1204
1205     if (mpDocSh)
1206         mpDocSh->GetDocument().RemoveUnoObject(*this);
1207     if (mpEditEngine)
1208         mpEditEngine->SetNotifyHdl(Link<EENotify&,void>());
1209     mpEditEngine.reset();
1210     mpForwarder.reset();
1211 }
1212
1213 ScAccessibleTextData* ScAccessibleNoteTextData::Clone() const
1214 {
1215     return new ScAccessibleNoteTextData(mpViewShell, msText, maCellPos, mbMarkNote);
1216 }
1217
1218 void ScAccessibleNoteTextData::Notify( SfxBroadcaster&, const SfxHint& rHint )
1219 {
1220     if ( rHint.GetId() == SfxHintId::Dying )
1221     {
1222         mpViewShell = nullptr;// invalid now
1223         mpDocSh = nullptr;
1224         if (mpViewForwarder)
1225             mpViewForwarder->SetInvalid();
1226     }
1227 }
1228
1229 SvxTextForwarder* ScAccessibleNoteTextData::GetTextForwarder()
1230 {
1231     if (!mpEditEngine)
1232     {
1233         if ( mpDocSh )
1234         {
1235             ScDocument& rDoc = mpDocSh->GetDocument();
1236             mpEditEngine = rDoc.CreateFieldEditEngine();
1237         }
1238         else
1239         {
1240             SfxItemPool* pEnginePool = EditEngine::CreatePool();
1241             pEnginePool->FreezeIdRanges();
1242             mpEditEngine.reset( new ScFieldEditEngine(nullptr, pEnginePool, nullptr, true) );
1243         }
1244         mpEditEngine->EnableUndo( false );
1245         if (mpDocSh)
1246             mpEditEngine->SetRefDevice(mpDocSh->GetRefDevice());
1247         else
1248             mpEditEngine->SetRefMapMode(MapMode(MapUnit::Map100thMM));
1249         mpForwarder.reset( new SvxEditEngineForwarder(*mpEditEngine) );
1250     }
1251
1252     if (mbDataValid)
1253         return mpForwarder.get();
1254
1255     if (!msText.isEmpty())
1256     {
1257
1258         if ( mpViewShell  )
1259         {
1260             Size aOutputSize;
1261             vcl::Window* pWindow = mpViewShell->GetWindow();
1262             if ( pWindow )
1263                 aOutputSize = pWindow->GetOutputSizePixel();
1264             tools::Rectangle aVisRect( Point(), aOutputSize );
1265             Size aSize(mpViewShell->GetLocationData().GetNoteInRangeOutputRect(aVisRect, mbMarkNote, maCellPos).GetSize());
1266             if (pWindow)
1267                 aSize = pWindow->PixelToLogic(aSize, mpEditEngine->GetRefMapMode());
1268             mpEditEngine->SetPaperSize(aSize);
1269         }
1270         mpEditEngine->SetTextCurrentDefaults( msText );
1271     }
1272
1273     mbDataValid = true;
1274
1275     mpEditEngine->SetNotifyHdl( LINK(this, ScAccessibleNoteTextData, NotifyHdl) );
1276
1277     return mpForwarder.get();
1278 }
1279
1280 SvxViewForwarder* ScAccessibleNoteTextData::GetViewForwarder()
1281 {
1282     if (!mpViewForwarder)
1283         mpViewForwarder = new ScPreviewNoteViewForwarder(mpViewShell);
1284     return mpViewForwarder;
1285 }
1286
1287 // CSV import =================================================================
1288
1289 class ScCsvViewForwarder : public SvxViewForwarder
1290 {
1291     VclPtr<OutputDevice>        mpWindow;
1292
1293 public:
1294     explicit                    ScCsvViewForwarder( OutputDevice* pWindow );
1295
1296     virtual bool                IsValid() const override;
1297     virtual Point               LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const override;
1298     virtual Point               PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const override;
1299
1300     void                        SetInvalid();
1301 };
1302
1303 ScCsvViewForwarder::ScCsvViewForwarder( OutputDevice* pWindow ) :
1304     mpWindow( pWindow )
1305 {
1306 }
1307
1308 bool ScCsvViewForwarder::IsValid() const
1309 {
1310     return mpWindow != nullptr;
1311 }
1312
1313 Point ScCsvViewForwarder::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
1314 {
1315     if( !mpWindow ) return Point();
1316     return mpWindow->LogicToPixel( rPoint, rMapMode );
1317 }
1318
1319 Point ScCsvViewForwarder::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
1320 {
1321     if( !mpWindow ) return Point();
1322     return mpWindow->PixelToLogic( rPoint, rMapMode );
1323 }
1324
1325 void ScCsvViewForwarder::SetInvalid()
1326 {
1327     mpWindow = nullptr;
1328 }
1329
1330 ScAccessibleCsvTextData::ScAccessibleCsvTextData(
1331         OutputDevice* pWindow, EditEngine* pEditEngine,
1332         const OUString& rCellText, const Size& rCellSize ) :
1333     mpWindow( pWindow ),
1334     mpEditEngine( pEditEngine ),
1335     maCellText( rCellText ),
1336     maCellSize( rCellSize )
1337 {
1338 }
1339
1340 ScAccessibleCsvTextData::~ScAccessibleCsvTextData()
1341 {
1342 }
1343
1344 void ScAccessibleCsvTextData::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1345 {
1346     if ( rHint.GetId() == SfxHintId::Dying )
1347     {
1348         mpWindow = nullptr;
1349         mpEditEngine = nullptr;
1350         if (mpViewForwarder)
1351             mpViewForwarder->SetInvalid();
1352     }
1353     ScAccessibleTextData::Notify( rBC, rHint );
1354 }
1355
1356 ScAccessibleTextData* ScAccessibleCsvTextData::Clone() const
1357 {
1358     return new ScAccessibleCsvTextData( mpWindow, mpEditEngine, maCellText, maCellSize );
1359 }
1360
1361 SvxTextForwarder* ScAccessibleCsvTextData::GetTextForwarder()
1362 {
1363     if( mpEditEngine )
1364     {
1365         mpEditEngine->SetPaperSize( maCellSize );
1366         mpEditEngine->SetText( maCellText );
1367         if( !mpTextForwarder )
1368             mpTextForwarder.reset( new SvxEditEngineForwarder( *mpEditEngine ) );
1369     }
1370     else
1371         mpTextForwarder.reset();
1372     return mpTextForwarder.get();
1373 }
1374
1375 SvxViewForwarder* ScAccessibleCsvTextData::GetViewForwarder()
1376 {
1377     if( !mpViewForwarder )
1378         mpViewForwarder.reset( new ScCsvViewForwarder( mpWindow ) );
1379     return mpViewForwarder.get();
1380 }
1381
1382 SvxEditViewForwarder* ScAccessibleCsvTextData::GetEditViewForwarder( bool /* bCreate */ )
1383 {
1384     return nullptr;
1385 }
1386
1387 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */