svx/source/svdraw/svdpntv.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 <memory>
  21 #include <svx/svdpntv.hxx>
  22 #include <vcl/weld.hxx>
  23 #include <vcl/window.hxx>
  24 #include <svx/sdrpaintwindow.hxx>
  25 #include <svx/svdmodel.hxx>
  26
  27 #include <svx/svdpage.hxx>
  28 #include <svx/svdpagv.hxx>
  29 #include <svl/hint.hxx>
  30
  31 #include <svx/svdview.hxx>
  32 #include <svx/svdglue.hxx>
  33 #include <svx/svdobj.hxx>
  34 #include <sxlayitm.hxx>
  35 #include <svl/itemiter.hxx>
  36 #include <editeng/eeitem.hxx>
  37 #include <svl/whiter.hxx>
  38 #include <svl/style.hxx>
  39 #include <svx/sdrpagewindow.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <svx/sdr/contact/objectcontact.hxx>
  42 #include <svx/sdr/animation/objectanimator.hxx>
  43 #include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
  44 #include <drawinglayer/converters.hxx>
  45 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  46 #include <comphelper/lok.hxx>
  47 #include <svx/svdviter.hxx>
  48 #include <osl/diagnose.h>
  49 #include <officecfg/Office/Common.hxx>
  50
  51 using namespace ::com::sun::star;
  52
  53 // interface to SdrPaintWindow
  54
  55 SdrPaintWindow* SdrPaintView::FindPaintWindow(const OutputDevice& rOut) const
  56 {
  57     // back to loop - there is more to test than a std::find_if and a lambda can do
  58     for(auto& candidate : maPaintWindows)
  59     {
  60         if(&(candidate->GetOutputDevice()) == &rOut)
  61         {
  62             return candidate.get();
  63         }
  64
  65         // check for patched to allow finding in that state, too
  66         if(nullptr != candidate->getPatched() && &(candidate->getPatched()->GetOutputDevice()) == &rOut)
  67         {
  68             return candidate->getPatched();
  69         }
  70     }
  71
  72     return nullptr;
  73 }
  74
  75 SdrPaintWindow* SdrPaintView::GetPaintWindow(sal_uInt32 nIndex) const
  76 {
  77     return maPaintWindows[nIndex].get();
  78 }
  79
  80 void SdrPaintView::DeletePaintWindow(const SdrPaintWindow& rOld)
  81 {
  82     auto aFindResult = ::std::find_if(maPaintWindows.begin(), maPaintWindows.end(),
  83                             [&](const std::unique_ptr<SdrPaintWindow>& p) { return p.get() == &rOld; });
  84
  85     if(aFindResult != maPaintWindows.end())
  86     {
  87         maPaintWindows.erase(aFindResult);
  88     }
  89 }
  90
  91 OutputDevice* SdrPaintView::GetFirstOutputDevice() const
  92 {
  93     if(PaintWindowCount())
  94     {
  95         return &(GetPaintWindow(0)->GetOutputDevice());
  96     }
  97
  98     return nullptr;
  99 }
 100
 101
 102 SvxViewChangedHint::SvxViewChangedHint() : SfxHint(SfxHintId::SvxViewChanged)
 103 {
 104 }
 105
 106
 107 BitmapEx convertMetafileToBitmapEx(
 108     const GDIMetaFile& rMtf,
 109     const basegfx::B2DRange& rTargetRange,
 110     const sal_uInt32 nMaximumQuadraticPixels)
 111 {
 112     BitmapEx aBitmapEx;
 113
 114     if(rMtf.GetActionSize())
 115     {
 116         const drawinglayer::primitive2d::Primitive2DReference aMtf(
 117             new drawinglayer::primitive2d::MetafilePrimitive2D(
 118                 basegfx::utils::createScaleTranslateB2DHomMatrix(
 119                     rTargetRange.getRange(),
 120                     rTargetRange.getMinimum()),
 121                 rMtf));
 122         aBitmapEx = drawinglayer::convertPrimitive2DContainerToBitmapEx(
 123             drawinglayer::primitive2d::Primitive2DContainer { aMtf },
 124             rTargetRange,
 125             nMaximumQuadraticPixels);
 126     }
 127
 128     return aBitmapEx;
 129 }
 130
 131 SdrPaintView::SdrPaintView(SdrModel& rSdrModel, OutputDevice* pOut)
 132     : mrModel(rSdrModel)
 133     , mpActualOutDev(nullptr)
 134     , mpDragWin(nullptr)
 135     , mpDefaultStyleSheet(nullptr)
 136     , maDefaultAttr(rSdrModel.GetItemPool())
 137     , maComeBackIdle( "svx::SdrPaintView aComeBackIdle" )
 138     , meAnimationMode(SdrAnimationMode::Animate)
 139     , mnHitTolPix(2)
 140     , mnMinMovPix(3)
 141     , mnHitTolLog(0)
 142     , mnMinMovLog(0)
 143     , mbPageVisible(true)
 144     , mbPageShadowVisible(true)
 145     , mbPageBorderVisible(true)
 146     , mbBordVisible(true)
 147     , mbGridVisible(true)
 148     , mbGridFront(false)
 149     , mbHlplVisible(true)
 150     , mbHlplFront(true)
 151     , mbGlueVisible(false)
 152     , mbGlueVisible2(false)
 153     , mbGlueVisible3(false)
 154     , mbGlueVisible4(false)
 155     , mbSomeObjChgdFlag(false)
 156     , mbSwapAsynchron(false)
 157     , mbPrintPreview(false)
 158     , mbAnimationPause(false)
 159     , mbBufferedOutputAllowed(false)
 160     , mbBufferedOverlayAllowed(false)
 161     , mbPageDecorationAllowed(true)
 162     , mbMasterPageVisualizationAllowed(true)
 163     , mbPreviewRenderer(false)
 164     , mbHideOle(false)
 165     , mbHideChart(false)
 166     , mbHideDraw(false)
 167     , mbHideFormControl(false)
 168     , mbHideBackground(false)
 169     , mbPaintTextEdit(true)
 170     , maGridColor(COL_BLACK)
 171 {
 172     maComeBackIdle.SetPriority(TaskPriority::REPAINT);
 173     maComeBackIdle.SetInvokeHandler(LINK(this,SdrPaintView,ImpComeBackHdl));
 174
 175     SetDefaultStyleSheet(GetModel().GetDefaultStyleSheet(), true);
 176
 177     if (pOut)
 178         AddDeviceToPaintView(*pOut, nullptr);
 179
 180     maColorConfig.AddListener(this);
 181     onChangeColorConfig();
 182 }
 183
 184 SdrPaintView::~SdrPaintView()
 185 {
 186     if (mpDefaultStyleSheet)
 187         EndListening(*mpDefaultStyleSheet);
 188
 189     maColorConfig.RemoveListener(this);
 190     ClearPageView();
 191
 192     // delete existing SdrPaintWindows
 193     maPaintWindows.clear();
 194 }
 195
 196
 197 void SdrPaintView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 198 {
 199     //If the stylesheet has been destroyed
 200     if (&rBC == mpDefaultStyleSheet)
 201     {
 202         if (rHint.GetId() == SfxHintId::Dying)
 203             mpDefaultStyleSheet = nullptr;
 204         return;
 205     }
 206
 207     if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
 208         return;
 209     const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
 210     SdrHintKind eKind = pSdrHint->GetKind();
 211     if (eKind==SdrHintKind::ObjectChange || eKind==SdrHintKind::ObjectInserted || eKind==SdrHintKind::ObjectRemoved)
 212     {
 213         bool bObjChg = !mbSomeObjChgdFlag; // if true, evaluate for ComeBack timer
 214         if (bObjChg)
 215         {
 216             mbSomeObjChgdFlag=true;
 217             maComeBackIdle.Start();
 218         }
 219     }
 220
 221     if (eKind==SdrHintKind::PageOrderChange)
 222     {
 223         const SdrPage* pPg=pSdrHint->GetPage();
 224         if (pPg && !pPg->IsInserted())
 225         {
 226             if(mpPageView && mpPageView->GetPage() == pPg)
 227             {
 228                 HideSdrPage();
 229             }
 230         }
 231     }
 232 }
 233
 234 void SdrPaintView::ConfigurationChanged( ::utl::ConfigurationBroadcaster* , ConfigurationHints eHint)
 235 {
 236     if (eHint == ConfigurationHints::OnlyCurrentDocumentColorScheme)
 237         return;
 238     onChangeColorConfig();
 239     InvalidateAllWin();
 240 }
 241
 242 IMPL_LINK_NOARG(SdrPaintView, ImpComeBackHdl, Timer *, void)
 243 {
 244     if (mbSomeObjChgdFlag) {
 245         mbSomeObjChgdFlag=false;
 246         ModelHasChanged();
 247     }
 248 }
 249
 250 void SdrPaintView::FlushComeBackTimer() const
 251 {
 252     if (mbSomeObjChgdFlag) {
 253         // casting to nonconst
 254         const_cast<SdrPaintView*>(this)->ImpComeBackHdl(&const_cast<SdrPaintView*>(this)->maComeBackIdle);
 255         const_cast<SdrPaintView*>(this)->maComeBackIdle.Stop();
 256     }
 257 }
 258
 259 void SdrPaintView::ModelHasChanged()
 260 {
 261     // broadcast to all PageViews
 262     if(mpPageView && !mpPageView->GetPage()->IsInserted())
 263     {
 264         HideSdrPage();
 265     }
 266
 267     // test mpPageView here again, HideSdrPage() may have invalidated it.
 268     if(mpPageView)
 269     {
 270         mpPageView->ModelHasChanged();
 271     }
 272 }
 273
 274
 275 bool SdrPaintView::IsAction() const
 276 {
 277     return false;
 278 }
 279
 280 void SdrPaintView::MovAction(const Point&)
 281 {
 282 }
 283
 284 void SdrPaintView::EndAction()
 285 {
 286 }
 287
 288 void SdrPaintView::BckAction()
 289 {
 290 }
 291
 292 void SdrPaintView::BrkAction()
 293 {
 294 }
 295
 296 void SdrPaintView::TakeActionRect(tools::Rectangle&) const
 297 {
 298 }
 299
 300
 301 // info about TextEdit. Default is false.
 302 bool SdrPaintView::IsTextEdit() const
 303 {
 304     return false;
 305 }
 306
 307 sal_uInt16 SdrPaintView::ImpGetMinMovLogic(short nMinMov, const OutputDevice* pOut) const
 308 {
 309     if (nMinMov>=0) return sal_uInt16(nMinMov);
 310     if (pOut==nullptr)
 311     {
 312         pOut = GetFirstOutputDevice();
 313     }
 314     if (pOut!=nullptr) {
 315         return short(-pOut->PixelToLogic(Size(nMinMov,0)).Width());
 316     } else {
 317         return 0;
 318     }
 319 }
 320
 321 sal_uInt16 SdrPaintView::ImpGetHitTolLogic(short nHitTol, const OutputDevice* pOut) const
 322 {
 323     if (nHitTol>=0) return sal_uInt16(nHitTol);
 324     if (pOut==nullptr)
 325     {
 326         pOut = GetFirstOutputDevice();
 327     }
 328     if (pOut!=nullptr) {
 329         return short(-pOut->PixelToLogic(Size(nHitTol,0)).Width());
 330     } else {
 331         return 0;
 332     }
 333 }
 334
 335 void SdrPaintView::TheresNewMapMode()
 336 {
 337     if (mpActualOutDev) {
 338         if (comphelper::LibreOfficeKit::isActive())
 339         {
 340             mnHitTolLog=static_cast<sal_uInt16>(OutputDevice::LogicToLogic(Size(mnHitTolPix,0), MapMode(MapUnit::MapPixel), mpActualOutDev->GetMapMode()).Width());
 341             mnMinMovLog=static_cast<sal_uInt16>(OutputDevice::LogicToLogic(Size(mnMinMovPix,0), MapMode(MapUnit::MapPixel), mpActualOutDev->GetMapMode()).Width());
 342         }
 343         else
 344         {
 345             mnHitTolLog=static_cast<sal_uInt16>(mpActualOutDev->PixelToLogic(Size(mnHitTolPix,0)).Width());
 346             mnMinMovLog=static_cast<sal_uInt16>(mpActualOutDev->PixelToLogic(Size(mnMinMovPix,0)).Width());
 347         }
 348     }
 349 }
 350
 351 void SdrPaintView::SetActualWin(const OutputDevice* pWin)
 352 {
 353     mpActualOutDev = const_cast<OutputDevice *>(pWin);
 354     TheresNewMapMode();
 355 }
 356
 357
 358 void SdrPaintView::ClearPageView()
 359 {
 360     BrkAction();
 361
 362     if(mpPageView)
 363     {
 364         InvalidateAllWin();
 365         mpPageView.reset();
 366     }
 367 }
 368
 369 SdrPageView* SdrPaintView::ShowSdrPage(SdrPage* pPage)
 370 {
 371     if(pPage && (!mpPageView || mpPageView->GetPage() != pPage))
 372     {
 373         if(mpPageView)
 374         {
 375             InvalidateAllWin();
 376             mpPageView.reset();
 377         }
 378
 379         if (SdrView *pView = dynamic_cast<SdrView*>(this))
 380         {
 381             mpPageView.reset(new SdrPageView(pPage, *pView));
 382             mpPageView->Show();
 383         }
 384     }
 385
 386     return mpPageView.get();
 387 }
 388
 389 void SdrPaintView::HideSdrPage()
 390 {
 391     if(mpPageView)
 392     {
 393         mpPageView->Hide();
 394         mpPageView.reset();
 395     }
 396 }
 397
 398 void SdrPaintView::AddDeviceToPaintView(OutputDevice& rNewDev, vcl::Window *pWindow)
 399 {
 400     SdrPaintWindow* pNewPaintWindow = new SdrPaintWindow(*this, rNewDev, pWindow);
 401     maPaintWindows.emplace_back(pNewPaintWindow);
 402
 403     if(mpPageView)
 404     {
 405         mpPageView->AddPaintWindowToPageView(*pNewPaintWindow);
 406     }
 407 }
 408
 409 void SdrPaintView::DeleteDeviceFromPaintView(OutputDevice& rOldDev)
 410 {
 411     SdrPaintWindow* pCandidate = FindPaintWindow(rOldDev);
 412
 413     if(pCandidate)
 414     {
 415         if(mpPageView)
 416         {
 417             mpPageView->RemovePaintWindowFromPageView(*pCandidate);
 418         }
 419
 420         DeletePaintWindow(*pCandidate);
 421     }
 422 }
 423
 424 void SdrPaintView::SetLayerVisible(const OUString& rName, bool bShow)
 425 {
 426     const bool bChanged = mpPageView && mpPageView->SetLayerVisible(rName, bShow);
 427     if (!bChanged)
 428         return;
 429     InvalidateAllWin();
 430 }
 431
 432 bool SdrPaintView::IsLayerVisible(const OUString& rName) const
 433 {
 434     return mpPageView && mpPageView->IsLayerVisible(rName);
 435 }
 436
 437 void SdrPaintView::SetLayerLocked(const OUString& rName, bool bLock)
 438 {
 439     if(mpPageView)
 440     {
 441         mpPageView->SetLayerLocked(rName,bLock);
 442     }
 443 }
 444
 445 bool SdrPaintView::IsLayerLocked(const OUString& rName) const
 446 {
 447     if(mpPageView)
 448     {
 449         return mpPageView->IsLayerLocked(rName);
 450     }
 451
 452     return false;
 453 }
 454
 455 void SdrPaintView::SetLayerPrintable(const OUString& rName, bool bPrn)
 456 {
 457     if(mpPageView)
 458     {
 459         mpPageView->SetLayerPrintable(rName,bPrn);
 460     }
 461 }
 462
 463 bool SdrPaintView::IsLayerPrintable(const OUString& rName) const
 464 {
 465     if(mpPageView)
 466     {
 467         return mpPageView->IsLayerPrintable(rName);
 468     }
 469
 470     return false;
 471 }
 472
 473 void SdrPaintView::PrePaint()
 474 {
 475     if(mpPageView)
 476     {
 477         mpPageView->PrePaint();
 478     }
 479 }
 480
 481
 482 // #define SVX_REPAINT_TIMER_TEST
 483
 484 void SdrPaintView::CompleteRedraw(OutputDevice* pOut, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector)
 485 {
 486 #ifdef SVX_REPAINT_TIMER_TEST
 487 #define REMEMBERED_TIMES_COUNT  (10)
 488     static bool bDoTimerTest(false);
 489     static bool bTimesInited(false);
 490     static sal_uInt32 nRepeatCount(10);
 491     static double fLastTimes[REMEMBERED_TIMES_COUNT];
 492     const sal_uInt64 nStartTime(tools::Time::GetSystemTicks());
 493     sal_uInt32 count(1);
 494     sal_uInt32 a;
 495
 496     if(bDoTimerTest)
 497     {
 498         count = nRepeatCount;
 499     }
 500
 501     for(a = 0; a < count; a++)
 502     {
 503 #endif // SVX_REPAINT_TIMER_TEST
 504
 505     // #i74769# check if pOut is a win and has a ClipRegion. If Yes, the Region
 506     // rReg may be made more granular (fine) with using it. Normally, rReg
 507     // does come from Window::Paint() anyways and thus is based on a single
 508     // rectangle which was derived from exactly that repaint region
 509     vcl::Region aOptimizedRepaintRegion(rReg);
 510
 511     if(pOut && OUTDEV_WINDOW == pOut->GetOutDevType())
 512     {
 513         vcl::Window* pWindow = pOut->GetOwnerWindow();
 514
 515         if(pWindow->IsInPaint())
 516         {
 517             if(!pWindow->GetPaintRegion().IsEmpty())
 518             {
 519                 aOptimizedRepaintRegion.Intersect(pWindow->GetPaintRegion());
 520             }
 521         }
 522     }
 523
 524     SdrPaintWindow* pPaintWindow = BeginCompleteRedraw(pOut);
 525     assert(pPaintWindow && "SdrPaintView::CompleteRedraw: No OutDev (!)");
 526
 527     DoCompleteRedraw(*pPaintWindow, aOptimizedRepaintRegion, pRedirector);
 528     EndCompleteRedraw(*pPaintWindow, true);
 529
 530 #ifdef SVX_REPAINT_TIMER_TEST
 531     }
 532
 533     if(bDoTimerTest)
 534     {
 535         const sal_uInt64 nStopTime(tools::Time::GetSystemTicks());
 536         const sal_uInt64 nNeededTime(nStopTime - nStartTime);
 537         const double fTimePerPaint((double)nNeededTime / (double)nRepeatCount);
 538
 539         if(!bTimesInited)
 540         {
 541             for(a = 0; a < REMEMBERED_TIMES_COUNT; a++)
 542             {
 543                 fLastTimes[a] = fTimePerPaint;
 544             }
 545
 546             bTimesInited = true;
 547         }
 548         else
 549         {
 550             for(a = 1; a < REMEMBERED_TIMES_COUNT; a++)
 551             {
 552                 fLastTimes[a - 1] = fLastTimes[a];
 553             }
 554
 555             fLastTimes[REMEMBERED_TIMES_COUNT - 1] = fTimePerPaint;
 556         }
 557
 558         double fAddedTimes(0.0);
 559
 560         for(a = 0; a < REMEMBERED_TIMES_COUNT; a++)
 561         {
 562             fAddedTimes += fLastTimes[a];
 563         }
 564
 565         const double fAverageTimePerPaint(fAddedTimes / (double)REMEMBERED_TIMES_COUNT);
 566
 567         fprintf(stderr, "-----------(start result)----------\n");
 568         fprintf(stderr, "StartTime : %" SAL_PRIuUINT64 ", StopTime: %" SAL_PRIuUINT64 ", NeededTime: %" SAL_PRIuUINT64 ", TimePerPaint: %f\n", nStartTime, nStopTime, nNeededTime, fTimePerPaint);
 569         fprintf(stderr, "Remembered times: ");
 570
 571         for(a = 0; a < REMEMBERED_TIMES_COUNT; a++)
 572         {
 573             fprintf(stderr, "%d: %f ", a, fLastTimes[a]);
 574         }
 575
 576         fprintf(stderr, "\n");
 577         fprintf(stderr, "AverageTimePerPaint: %f\n", fAverageTimePerPaint);
 578         fprintf(stderr, "-----------(stop result)----------\n");
 579     }
 580 #endif // SVX_REPAINT_TIMER_TEST
 581 }
 582
 583
 584 // #i72889#
 585
 586 SdrPaintWindow* SdrPaintView::BeginCompleteRedraw(OutputDevice* pOut)
 587 {
 588     assert(pOut && "SdrPaintView::BeginCompleteRedraw: No OutDev (!)");
 589     SdrPaintWindow* pPaintWindow = FindPaintWindow(*pOut);
 590
 591     if(pPaintWindow)
 592     {
 593         // draw preprocessing, only for known devices
 594         // prepare PreRendering
 595         pPaintWindow->PreparePreRenderDevice();
 596     }
 597     else
 598     {
 599         // None of the known OutputDevices is the target of this paint, use
 600         // a temporary SdrPaintWindow for this Redraw.
 601         pPaintWindow = new SdrPaintWindow(*this, *pOut);
 602         pPaintWindow->setTemporaryTarget(true);
 603     }
 604
 605     return pPaintWindow;
 606 }
 607
 608 void SdrPaintView::DoCompleteRedraw(SdrPaintWindow& rPaintWindow, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector)
 609 {
 610     // redraw all PageViews with the target. This may expand the RedrawRegion
 611     // at the PaintWindow, plus taking care of FormLayer expansion
 612     if(mpPageView)
 613     {
 614         mpPageView->CompleteRedraw(rPaintWindow, rReg, pRedirector);
 615     }
 616 }
 617
 618 void SdrPaintView::EndCompleteRedraw(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer,
 619         sdr::contact::ViewObjectContactRedirector* pRedirector)
 620 {
 621     std::unique_ptr<SdrPaintWindow> pPaintWindow;
 622     if (comphelper::LibreOfficeKit::isActive() && rPaintWindow.getTemporaryTarget())
 623     {
 624         // Tiled rendering, we must paint the TextEdit to the output device.
 625         pPaintWindow.reset(&rPaintWindow);
 626         pPaintWindow->setTemporaryTarget(false);
 627     }
 628
 629     if(rPaintWindow.getTemporaryTarget())
 630     {
 631         // get rid of temp target again
 632         delete &rPaintWindow;
 633     }
 634     else
 635     {
 636         // draw postprocessing, only for known devices
 637         // it is necessary to always paint FormLayer
 638         // In the LOK case control rendering is performed through LokControlHandler
 639         if(!comphelper::LibreOfficeKit::isActive() && bPaintFormLayer)
 640         {
 641             ImpFormLayerDrawing(rPaintWindow, pRedirector);
 642         }
 643
 644         // look for active TextEdit. As long as this cannot be painted to a VDev,
 645         // it cannot get part of buffering. In that case, output evtl. prerender
 646         // early and paint text edit to window.
 647         SdrPageView* pPageView = GetSdrPageView();
 648         if(IsTextEdit() && pPageView)
 649         {
 650             if (!comphelper::LibreOfficeKit::isActive() || mbPaintTextEdit)
 651                 static_cast< SdrView* >(this)->TextEditDrawing(rPaintWindow);
 652         }
 653
 654         if (comphelper::LibreOfficeKit::isActive() && pPageView)
 655         {
 656             // Look for active text edits in other views showing the same page,
 657             // and show them as well. Show only if Page/MasterPage mode is matching.
 658             bool bRequireMasterPage = pPageView->GetPage() ? pPageView->GetPage()->IsMasterPage() : false;
 659             SdrViewIter::ForAllViews(pPageView->GetPage(),
 660                 [this, &bRequireMasterPage, &rPaintWindow] (SdrView* pView)
 661                 {
 662                     SdrPageView* pCurrentPageView = pView->GetSdrPageView();
 663                     bool bIsCurrentMasterPage = (pCurrentPageView && pCurrentPageView->GetPage()) ?
 664                         pCurrentPageView->GetPage()->IsMasterPage() : false;
 665
 666                     if (pView == this || bRequireMasterPage != bIsCurrentMasterPage)
 667                         return false;
 668
 669                     if (pView->IsTextEdit() && pView->GetSdrPageView())
 670                     {
 671                         pView->TextEditDrawing(rPaintWindow);
 672                     }
 673                     return false;
 674                 });
 675         }
 676
 677         // draw Overlay, also to PreRender device if exists
 678         rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion());
 679
 680         // output PreRendering
 681         rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
 682     }
 683 }
 684
 685 SdrPaintWindow* SdrPaintView::BeginDrawLayers(OutputDevice* pOut, const vcl::Region& rReg, bool bDisableIntersect)
 686 {
 687     // #i74769# use BeginCompleteRedraw() as common base
 688     SdrPaintWindow* pPaintWindow = BeginCompleteRedraw(pOut);
 689     assert(pPaintWindow && "SdrPaintView::BeginDrawLayers: No SdrPaintWindow (!)");
 690
 691     if(mpPageView)
 692     {
 693         SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(*pPaintWindow);
 694
 695         if(pKnownTarget)
 696         {
 697             vcl::Region aOptimizedRepaintRegion = OptimizeDrawLayersRegion( pOut, rReg, bDisableIntersect );
 698
 699             // prepare redraw
 700             pKnownTarget->PrepareRedraw(aOptimizedRepaintRegion);
 701
 702             // remember prepared SdrPageWindow
 703             mpPageView->setPreparedPageWindow(pKnownTarget);
 704         }
 705     }
 706
 707     return pPaintWindow;
 708 }
 709
 710 void SdrPaintView::EndDrawLayers(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer,
 711     sdr::contact::ViewObjectContactRedirector* pRedirector)
 712 {
 713     // #i74769# use EndCompleteRedraw() as common base
 714     EndCompleteRedraw(rPaintWindow, bPaintFormLayer, pRedirector);
 715
 716     if(mpPageView)
 717     {
 718         // forget prepared SdrPageWindow
 719         mpPageView->setPreparedPageWindow(nullptr);
 720     }
 721 }
 722
 723 void SdrPaintView::UpdateDrawLayersRegion(const OutputDevice* pOut, const vcl::Region& rReg)
 724 {
 725     SdrPaintWindow* pPaintWindow = FindPaintWindow(*pOut);
 726     assert(pPaintWindow && "SdrPaintView::UpdateDrawLayersRegion: No SdrPaintWindow (!)");
 727
 728     if(mpPageView)
 729     {
 730         SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(*pPaintWindow);
 731
 732         if(pKnownTarget)
 733         {
 734             vcl::Region aOptimizedRepaintRegion = OptimizeDrawLayersRegion( pOut, rReg, false/*bDisableIntersect*/ );
 735             pKnownTarget->GetPaintWindow().SetRedrawRegion(aOptimizedRepaintRegion);
 736             mpPageView->setPreparedPageWindow(pKnownTarget); // already set actually
 737         }
 738     }
 739 }
 740
 741 vcl::Region SdrPaintView::OptimizeDrawLayersRegion(const OutputDevice* pOut, const vcl::Region& rReg, bool bDisableIntersect)
 742 {
 743     // #i74769# check if pOut is a win and has a ClipRegion. If Yes, the Region
 744     // rReg may be made more granular (fine) with using it. Normally, rReg
 745     // does come from Window::Paint() anyways and thus is based on a single
 746     // rectangle which was derived from exactly that repaint region
 747     vcl::Region aOptimizedRepaintRegion(rReg);
 748
 749     // #i76114# Intersecting the region with the Window's paint region is disabled
 750     // for print preview in Calc, because the intersection can be empty (if the paint
 751     // region is outside of the table area of the page), and then no clip region
 752     // would be set.
 753     if(pOut && OUTDEV_WINDOW == pOut->GetOutDevType() && !bDisableIntersect)
 754     {
 755         vcl::Window* pWindow = pOut->GetOwnerWindow();
 756
 757         if(pWindow->IsInPaint())
 758         {
 759             if(!pWindow->GetPaintRegion().IsEmpty())
 760             {
 761                 aOptimizedRepaintRegion.Intersect(pWindow->GetPaintRegion());
 762             }
 763         }
 764     }
 765     return aOptimizedRepaintRegion;
 766 }
 767
 768
 769 void SdrPaintView::ImpFormLayerDrawing( SdrPaintWindow& rPaintWindow,
 770         sdr::contact::ViewObjectContactRedirector* pRedirector )
 771 {
 772     if(!mpPageView)
 773         return;
 774
 775     SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(rPaintWindow);
 776
 777     if(pKnownTarget)
 778     {
 779         const SdrModel& rModel = GetModel();
 780         const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin();
 781         const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName());
 782
 783         // BUFFERED use GetTargetOutputDevice() now, it may be targeted to VDevs, too
 784         // need to set PreparedPageWindow to make DrawLayer use the correct ObjectContact
 785         mpPageView->setPreparedPageWindow(pKnownTarget);
 786         mpPageView->DrawLayer(nControlLayerId, &rPaintWindow.GetTargetOutputDevice(),
 787         pRedirector);
 788         mpPageView->setPreparedPageWindow(nullptr);
 789     }
 790 }
 791
 792
 793 bool SdrPaintView::KeyInput(const KeyEvent& /*rKEvt*/, vcl::Window* /*pWin*/)
 794 {
 795     return false;
 796 }
 797
 798 void SdrPaintView::GlueInvalidate() const
 799 {
 800     // Do not invalidate GluePoints in Online
 801     // They are handled on front-end
 802     if (comphelper::LibreOfficeKit::isActive())
 803         return;
 804
 805     const sal_uInt32 nWindowCount(PaintWindowCount());
 806
 807     for(sal_uInt32 nWinNum(0); nWinNum < nWindowCount; nWinNum++)
 808     {
 809         SdrPaintWindow* pPaintWindow = GetPaintWindow(nWinNum);
 810
 811         if(pPaintWindow->OutputToWindow())
 812         {
 813             OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
 814
 815             if(mpPageView)
 816             {
 817                 const SdrObjList* pOL=mpPageView->GetObjList();
 818                 for (const rtl::Reference<SdrObject>& pObj : *pOL) {
 819                     const SdrGluePointList* pGPL=pObj->GetGluePointList();
 820                     if (pGPL!=nullptr && pGPL->GetCount()!=0) {
 821                         pGPL->Invalidate(*rOutDev.GetOwnerWindow(), pObj.get());
 822                     }
 823                 }
 824             }
 825         }
 826     }
 827 }
 828
 829 void SdrPaintView::InvalidateAllWin()
 830 {
 831     const sal_uInt32 nWindowCount(PaintWindowCount());
 832
 833     for(sal_uInt32 a(0); a < nWindowCount; a++)
 834     {
 835         SdrPaintWindow* pPaintWindow = GetPaintWindow(a);
 836
 837         if(pPaintWindow->OutputToWindow())
 838         {
 839             InvalidateOneWin(pPaintWindow->GetOutputDevice());
 840         }
 841     }
 842 }
 843
 844 void SdrPaintView::InvalidateAllWin(const tools::Rectangle& rRect)
 845 {
 846     const sal_uInt32 nWindowCount(PaintWindowCount());
 847
 848     for(sal_uInt32 a(0); a < nWindowCount; a++)
 849     {
 850         SdrPaintWindow* pPaintWindow = GetPaintWindow(a);
 851
 852         if(pPaintWindow->OutputToWindow())
 853         {
 854             OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
 855             tools::Rectangle aRect(rRect);
 856
 857             Point aOrg(rOutDev.GetMapMode().GetOrigin());
 858             aOrg.setX(-aOrg.X() ); aOrg.setY(-aOrg.Y() );
 859             tools::Rectangle aOutRect(aOrg, rOutDev.GetOutputSize());
 860
 861             // In case of tiled rendering we want to get all invalidations, so visual area is not interesting.
 862             if (aRect.Overlaps(aOutRect) || comphelper::LibreOfficeKit::isActive())
 863             {
 864                 InvalidateOneWin(rOutDev, aRect);
 865             }
 866         }
 867     }
 868 }
 869
 870 void SdrPaintView::InvalidateOneWin(OutputDevice& rDevice)
 871 {
 872     // do not erase background, that causes flicker (!)
 873     // tdf#160444 check device's owner window is a nullptr
 874     // Since commit 563f7077f1dbce31ff95ee8d2e8d17b629693db1, the
 875     // device's owner window gets deleted before this object is
 876     // deleted.
 877     if (rDevice.GetOwnerWindow())
 878         rDevice.GetOwnerWindow()->Invalidate(InvalidateFlags::NoErase);
 879 }
 880
 881 void SdrPaintView::InvalidateOneWin(OutputDevice& rDevice, const tools::Rectangle& rRect)
 882 {
 883     // do not erase background, that causes flicker (!)
 884     rDevice.GetOwnerWindow()->Invalidate(rRect, InvalidateFlags::NoErase);
 885 }
 886
 887 void SdrPaintView::LeaveOneGroup()
 888 {
 889     if(mpPageView)
 890     {
 891         mpPageView->LeaveOneGroup();
 892     }
 893 }
 894
 895 void SdrPaintView::LeaveAllGroup()
 896 {
 897     if(mpPageView)
 898     {
 899         mpPageView->LeaveAllGroup();
 900     }
 901 }
 902
 903 bool SdrPaintView::IsGroupEntered() const
 904 {
 905     if(mpPageView)
 906     {
 907         return (mpPageView->GetEnteredLevel() != 0);
 908     }
 909
 910     return false;
 911 }
 912
 913 void SdrPaintView::SetNotPersistDefaultAttr(const SfxItemSet& rAttr)
 914 {
 915     // bReplaceAll has no effect here at all.
 916     bool bMeasure= dynamic_cast<const SdrView*>(this) != nullptr && static_cast<SdrView*>(this)->IsMeasureTool();
 917
 918     if (const SdrLayerIdItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LAYERID))
 919     {
 920         SdrLayerID nLayerId = pPoolItem->GetValue();
 921         const SdrLayer* pLayer = GetModel().GetLayerAdmin().GetLayerPerID(nLayerId);
 922         if (pLayer!=nullptr) {
 923             if (bMeasure) maMeasureLayer=pLayer->GetName();
 924             else maActualLayer=pLayer->GetName();
 925         }
 926     }
 927     if (const SdrLayerNameItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LAYERNAME))
 928     {
 929         if (bMeasure) maMeasureLayer = pPoolItem->GetValue();
 930         else maActualLayer = pPoolItem->GetValue();
 931     }
 932 }
 933
 934 void SdrPaintView::MergeNotPersistDefaultAttr(SfxItemSet& rAttr) const
 935 {
 936     // bOnlyHardAttr has no effect here at all.
 937     bool bMeasure= dynamic_cast<const SdrView*>(this) != nullptr && static_cast<const SdrView*>(this)->IsMeasureTool();
 938     const OUString& aNam = bMeasure ? maMeasureLayer : maActualLayer;
 939     rAttr.Put(SdrLayerNameItem(aNam));
 940     SdrLayerID nLayer = GetModel().GetLayerAdmin().GetLayerID(aNam);
 941     if (nLayer!=SDRLAYER_NOTFOUND) {
 942         rAttr.Put(SdrLayerIdItem(nLayer));
 943     }
 944 }
 945
 946 void SdrPaintView::SetDefaultAttr(const SfxItemSet& rAttr, bool bReplaceAll)
 947 {
 948 #ifdef DBG_UTIL
 949     {
 950         bool bHasEEFeatureItems=false;
 951         SfxItemIter aIter(rAttr);
 952         for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem;
 953              pItem = aIter.NextItem())
 954         {
 955             if (!IsInvalidItem(pItem)) {
 956                 sal_uInt16 nW=pItem->Which();
 957                 if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=true;
 958             }
 959         }
 960
 961         if(bHasEEFeatureItems)
 962         {
 963             std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,
 964                                                           VclMessageType::Info, VclButtonsType::Ok,
 965                                                           u"SdrPaintView::SetDefaultAttr(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents."_ustr));
 966             xInfoBox->run();
 967         }
 968     }
 969 #endif
 970     if (bReplaceAll) maDefaultAttr.Set(rAttr);
 971     else maDefaultAttr.Put(rAttr,false); // if FALSE, regard InvalidItems as "holes," not as Default
 972     SetNotPersistDefaultAttr(rAttr);
 973 }
 974
 975 void SdrPaintView::SetDefaultStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
 976 {
 977     if (mpDefaultStyleSheet)
 978         EndListening(*mpDefaultStyleSheet);
 979     mpDefaultStyleSheet=pStyleSheet;
 980     if (mpDefaultStyleSheet)
 981         StartListening(*mpDefaultStyleSheet);
 982
 983     if (pStyleSheet!=nullptr && !bDontRemoveHardAttr) {
 984         SfxWhichIter aIter(pStyleSheet->GetItemSet());
 985         sal_uInt16 nWhich=aIter.FirstWhich();
 986         while (nWhich!=0) {
 987             if (aIter.GetItemState()==SfxItemState::SET) {
 988                 maDefaultAttr.ClearItem(nWhich);
 989             }
 990             nWhich=aIter.NextWhich();
 991         }
 992     }
 993 }
 994
 995 void SdrPaintView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
 996 {
 997     if(bOnlyHardAttr || !mpDefaultStyleSheet)
 998     {
 999         rTargetSet.Put(maDefaultAttr, false);
1000     }
1001     else
1002     {
1003         // else merge with DefStyleSheet
1004         rTargetSet.Put(mpDefaultStyleSheet->GetItemSet(), false);
1005         rTargetSet.Put(maDefaultAttr, false);
1006     }
1007     MergeNotPersistDefaultAttr(rTargetSet);
1008 }
1009
1010 void SdrPaintView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
1011 {
1012     SetDefaultAttr(rSet,bReplaceAll);
1013 }
1014
1015 SfxStyleSheet* SdrPaintView::GetStyleSheet() const
1016 {
1017     return mpDefaultStyleSheet;
1018 }
1019
1020 void SdrPaintView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
1021 {
1022     SetDefaultStyleSheet(pStyleSheet,bDontRemoveHardAttr);
1023 }
1024
1025 void SdrPaintView::MakeVisible(const tools::Rectangle& rRect, vcl::Window& rWin)
1026 {
1027     // TODO: handle when the text cursor goes out of the chart area
1028     // However this hack avoids that the cursor gets misplaced wrt the text.
1029     if (comphelper::LibreOfficeKit::isActive() && rWin.IsChart())
1030     {
1031         return;
1032     }
1033
1034     MapMode aMap(rWin.GetMapMode());
1035     Size aActualSize(rWin.GetOutDev()->GetOutputSize());
1036
1037     if( aActualSize.IsEmpty() )
1038         return;
1039
1040     Size aNewSize(rRect.GetSize());
1041     bool bNewScale=false;
1042     bool bNeedMoreX=aNewSize.Width()>aActualSize.Width();
1043     bool bNeedMoreY=aNewSize.Height()>aActualSize.Height();
1044     if (bNeedMoreX || bNeedMoreY)
1045     {
1046         bNewScale=true;
1047         // set new MapMode (Size+Org) and invalidate everything
1048         Fraction aXFact(aNewSize.Width(),aActualSize.Width());
1049         Fraction aYFact(aNewSize.Height(),aActualSize.Height());
1050         if (aYFact>aXFact) aXFact=aYFact;
1051         aXFact*=aMap.GetScaleX();
1052         aXFact.ReduceInaccurate(10); // to avoid runovers and BigInt mapping
1053         aMap.SetScaleX(aXFact);
1054         aMap.SetScaleY(aYFact);
1055         rWin.SetMapMode(aMap);
1056         aActualSize=rWin.GetOutDev()->GetOutputSize();
1057     }
1058     Point aOrg(aMap.GetOrigin());
1059     tools::Long dx=0,dy=0;
1060     tools::Long l=-aOrg.X();
1061     tools::Long r=-aOrg.X()+aActualSize.Width()-1;
1062     tools::Long o=-aOrg.Y();
1063     tools::Long u=-aOrg.Y()+aActualSize.Height()-1;
1064     if (l>rRect.Left()) dx=rRect.Left()-l;
1065     else if (r<rRect.Right()) dx=rRect.Right()-r;
1066     if (o>rRect.Top()) dy=rRect.Top()-o;
1067     else if (u<rRect.Bottom()) dy=rRect.Bottom()-u;
1068     aMap.SetOrigin(Point(aOrg.X()-dx,aOrg.Y()-dy));
1069     if (!bNewScale) {
1070         if (dx!=0 || dy!=0) {
1071             rWin.Scroll(-dx,-dy);
1072             rWin.SetMapMode(aMap);
1073             rWin.PaintImmediately();
1074         }
1075     } else {
1076         rWin.SetMapMode(aMap);
1077         InvalidateOneWin(*rWin.GetOutDev());
1078     }
1079 }
1080
1081 void SdrPaintView::DoConnect(SdrOle2Obj* /*pOleObj*/)
1082 {
1083 }
1084
1085 void SdrPaintView::SetAnimationEnabled( bool bEnable )
1086 {
1087     SetAnimationMode( bEnable ? SdrAnimationMode::Animate : SdrAnimationMode::Disable );
1088 }
1089
1090 void SdrPaintView::SetAnimationPause( bool bSet )
1091 {
1092     if(mbAnimationPause == bSet)
1093         return;
1094
1095     mbAnimationPause = bSet;
1096
1097     if(!mpPageView)
1098         return;
1099
1100     for(sal_uInt32 b(0); b < mpPageView->PageWindowCount(); b++)
1101     {
1102         SdrPageWindow& rPageWindow = *(mpPageView->GetPageWindow(b));
1103         sdr::contact::ObjectContact& rObjectContact = rPageWindow.GetObjectContact();
1104         sdr::animation::primitiveAnimator& rAnimator = rObjectContact.getPrimitiveAnimator();
1105
1106         if(rAnimator.IsPaused() != bSet)
1107         {
1108             rAnimator.SetPaused(bSet);
1109         }
1110     }
1111 }
1112
1113 void SdrPaintView::SetAnimationMode( const SdrAnimationMode eMode )
1114 {
1115     meAnimationMode = eMode;
1116 }
1117
1118 void SdrPaintView::VisAreaChanged(const OutputDevice* pOut)
1119 {
1120     if(!mpPageView)
1121         return;
1122
1123     if (pOut)
1124     {
1125         SdrPageWindow* pWindow = mpPageView->FindPageWindow(*const_cast<OutputDevice*>(pOut));
1126
1127         if(pWindow)
1128         {
1129             VisAreaChanged();
1130         }
1131     }
1132     else
1133     {
1134         VisAreaChanged();
1135     }
1136 }
1137
1138 void SdrPaintView::VisAreaChanged()
1139 {
1140     // notify SfxListener
1141     Broadcast(SvxViewChangedHint());
1142 }
1143
1144
1145 void SdrPaintView::onChangeColorConfig()
1146 {
1147     maGridColor = maColorConfig.GetColorValue( svtools::DRAWGRID ).nColor;
1148 }
1149
1150
1151 // Set background color for svx at SdrPageViews
1152 void SdrPaintView::SetApplicationBackgroundColor(Color aBackgroundColor)
1153 {
1154     if(mpPageView)
1155     {
1156         mpPageView->SetApplicationBackgroundColor(aBackgroundColor);
1157     }
1158 }
1159
1160 // Set document color for svx at SdrPageViews
1161 void SdrPaintView::SetApplicationDocumentColor(Color aDocumentColor)
1162 {
1163     if(mpPageView)
1164     {
1165         mpPageView->SetApplicationDocumentColor(aDocumentColor);
1166     }
1167 }
1168
1169 bool SdrPaintView::IsBufferedOutputAllowed() const
1170 {
1171     return (mbBufferedOutputAllowed && officecfg::Office::Common::Drawinglayer::PaintBuffer::get());
1172 }
1173
1174 void SdrPaintView::SetBufferedOutputAllowed(bool bNew)
1175 {
1176     if(bNew != mbBufferedOutputAllowed)
1177     {
1178         mbBufferedOutputAllowed = bNew;
1179     }
1180 }
1181
1182 bool SdrPaintView::IsBufferedOverlayAllowed() const
1183 {
1184     return (mbBufferedOverlayAllowed && officecfg::Office::Common::Drawinglayer::OverlayBuffer::get());
1185 }
1186
1187 void SdrPaintView::SetBufferedOverlayAllowed(bool bNew)
1188 {
1189     if(bNew != mbBufferedOverlayAllowed)
1190     {
1191         mbBufferedOverlayAllowed = bNew;
1192     }
1193 }
1194
1195
1196 void SdrPaintView::SetPageDecorationAllowed(bool bNew)
1197 {
1198     if(bNew != mbPageDecorationAllowed)
1199     {
1200         mbPageDecorationAllowed = bNew;
1201     }
1202 }
1203
1204 void SdrPaintView::SetMasterPageVisualizationAllowed(bool bNew)
1205 {
1206     if(bNew != mbMasterPageVisualizationAllowed)
1207     {
1208         mbMasterPageVisualizationAllowed = bNew;
1209     }
1210 }
1211
1212 // #i38135# Sets the timer for Object animations and restarts.
1213 void SdrPaintView::SetAnimationTimer(sal_uInt32 nTime)
1214 {
1215     if(mpPageView)
1216     {
1217         // first, reset all timers at all windows to 0L
1218         for(sal_uInt32 a(0); a < mpPageView->PageWindowCount(); a++)
1219         {
1220             SdrPageWindow& rPageWindow = *mpPageView->GetPageWindow(a);
1221             sdr::contact::ObjectContact& rObjectContact = rPageWindow.GetObjectContact();
1222             sdr::animation::primitiveAnimator& rAnimator = rObjectContact.getPrimitiveAnimator();
1223             rAnimator.SetTime(nTime);
1224         }
1225     }
1226 }
1227
1228 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */