svx/source/svdraw/svdpagv.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 <svx/svdpagv.hxx>
  21 #include <svx/svdpage.hxx>
  22 #include <svx/svdview.hxx>
  23
  24 #include <svx/svdobj.hxx>
  25 #include <svx/svdogrp.hxx>
  26 #include <svx/svdtypes.hxx>
  27
  28 #include <svx/sdr/contact/viewobjectcontactredirector.hxx>
  29
  30 #include <algorithm>
  31
  32 #include <svx/sdrpagewindow.hxx>
  33 #include <svx/sdrpaintwindow.hxx>
  34 #include <comphelper/lok.hxx>
  35 #include <comphelper/scopeguard.hxx>
  36 #include <basegfx/range/b2irectangle.hxx>
  37 #include <osl/diagnose.h>
  38
  39 using namespace ::com::sun::star;
  40
  41 // interface to SdrPageWindow
  42
  43 SdrPageWindow* SdrPageView::FindPageWindow(const SdrPaintWindow& rPaintWindow) const
  44 {
  45     for(auto & a : maPageWindows)
  46     {
  47         if(&(a->GetPaintWindow()) == &rPaintWindow)
  48         {
  49             return a.get();
  50         }
  51     }
  52
  53     return nullptr;
  54 }
  55
  56 const SdrPageWindow* SdrPageView::FindPatchedPageWindow( const OutputDevice& _rOutDev ) const
  57 {
  58     for ( auto const & pPageWindow : maPageWindows )
  59     {
  60         const SdrPaintWindow& rPaintWindow( pPageWindow->GetOriginalPaintWindow() ? *pPageWindow->GetOriginalPaintWindow() : pPageWindow->GetPaintWindow() );
  61         if ( &rPaintWindow.GetOutputDevice() == &_rOutDev )
  62         {
  63             return pPageWindow.get();
  64         }
  65     }
  66
  67     return nullptr;
  68 }
  69
  70 SdrPageWindow* SdrPageView::FindPageWindow(const OutputDevice& rOutDev) const
  71 {
  72     for ( auto const & pPageWindow : maPageWindows )
  73     {
  74         if(&(pPageWindow->GetPaintWindow().GetOutputDevice()) == &rOutDev)
  75         {
  76             return pPageWindow.get();
  77         }
  78     }
  79
  80     return nullptr;
  81 }
  82
  83 SdrPageWindow* SdrPageView::GetPageWindow(sal_uInt32 nIndex) const
  84 {
  85     return maPageWindows[nIndex].get();
  86 }
  87
  88 SdrPageView::SdrPageView(SdrPage* pPage1, SdrView& rNewView)
  89 :   mrView(rNewView),
  90     // col_auto color lets the view takes the default SvxColorConfig entry
  91     maDocumentColor( COL_AUTO ),
  92     maBackgroundColor( COL_AUTO ), // #i48367# also react on autocolor
  93     mpPreparedPageWindow(nullptr) // #i72752#
  94 {
  95     mpPage = pPage1;
  96
  97     if(mpPage)
  98     {
  99         maPageOrigin.setX(mpPage->GetLeftBorder() );
 100         maPageOrigin.setY(mpPage->GetUpperBorder() );
 101     }
 102     // For example, in the case of charts, there is a LayerAdmin, but it has no valid values. Therefore
 103     // a solution like pLayerAdmin->getVisibleLayersODF(aLayerVisi) is not possible. So use the
 104     // generic SetAll() for now.
 105     aLayerVisi.SetAll();
 106     aLayerPrn.SetAll();
 107
 108     mbHasMarked = false;
 109     mbVisible = false;
 110     pCurrentList = nullptr;
 111     pCurrentGroup = nullptr;
 112     SetCurrentGroupAndList(nullptr, mpPage);
 113
 114     for(sal_uInt32 a(0); a < rNewView.PaintWindowCount(); a++)
 115     {
 116         AddPaintWindowToPageView(*rNewView.GetPaintWindow(a));
 117     }
 118 }
 119
 120 SdrPageView::~SdrPageView()
 121 {
 122 }
 123
 124 void SdrPageView::AddPaintWindowToPageView(SdrPaintWindow& rPaintWindow)
 125 {
 126     if(!FindPageWindow(rPaintWindow))
 127     {
 128         maPageWindows.emplace_back(new SdrPageWindow(*this, rPaintWindow));
 129     }
 130 }
 131
 132 void SdrPageView::RemovePaintWindowFromPageView(SdrPaintWindow& rPaintWindow)
 133 {
 134     auto it = std::find_if(maPageWindows.begin(), maPageWindows.end(),
 135         [&rPaintWindow](const std::unique_ptr<SdrPageWindow>& rpWindow) {
 136             return &(rpWindow->GetPaintWindow()) == &rPaintWindow;
 137         });
 138     if (it != maPageWindows.end())
 139         maPageWindows.erase(it);
 140 }
 141
 142 css::uno::Reference< css::awt::XControlContainer > SdrPageView::GetControlContainer( const OutputDevice& _rDevice ) const
 143 {
 144     css::uno::Reference< css::awt::XControlContainer > xReturn;
 145     const SdrPageWindow* pCandidate = FindPatchedPageWindow( _rDevice );
 146
 147     if ( pCandidate )
 148         xReturn = pCandidate->GetControlContainer();
 149
 150     return xReturn;
 151 }
 152
 153 void SdrPageView::ModelHasChanged()
 154 {
 155     if (GetCurrentGroup()!=nullptr) CheckCurrentGroup();
 156 }
 157
 158 bool SdrPageView::IsReadOnly() const
 159 {
 160     return (nullptr == GetPage() || GetView().GetModel().IsReadOnly() || GetPage()->IsReadOnly() || GetObjList()->IsReadOnly());
 161 }
 162
 163 void SdrPageView::Show()
 164 {
 165     if(!IsVisible())
 166     {
 167         mbVisible = true;
 168
 169         for(sal_uInt32 a(0); a < GetView().PaintWindowCount(); a++)
 170         {
 171             AddPaintWindowToPageView(*GetView().GetPaintWindow(a));
 172         }
 173     }
 174 }
 175
 176 void SdrPageView::Hide()
 177 {
 178     if(IsVisible())
 179     {
 180         if (!comphelper::LibreOfficeKit::isActive())
 181         {
 182             InvalidateAllWin();
 183         }
 184         mbVisible = false;
 185         maPageWindows.clear();
 186     }
 187 }
 188
 189 tools::Rectangle SdrPageView::GetPageRect() const
 190 {
 191     if (GetPage()==nullptr) return tools::Rectangle();
 192     return tools::Rectangle(Point(),Size(GetPage()->GetWidth()+1,GetPage()->GetHeight()+1));
 193 }
 194
 195 void SdrPageView::InvalidateAllWin()
 196 {
 197     if(IsVisible() && GetPage())
 198     {
 199         tools::Rectangle aRect(Point(0,0),Size(GetPage()->GetWidth()+1,GetPage()->GetHeight()+1));
 200         aRect.Union(GetPage()->GetAllObjBoundRect());
 201         GetView().InvalidateAllWin(aRect);
 202     }
 203 }
 204
 205
 206 void SdrPageView::PrePaint()
 207 {
 208     const sal_uInt32 nCount(PageWindowCount());
 209
 210     for(sal_uInt32 a(0); a < nCount; a++)
 211     {
 212         SdrPageWindow* pCandidate = GetPageWindow(a);
 213
 214         if(pCandidate)
 215         {
 216             pCandidate->PrePaint();
 217         }
 218     }
 219 }
 220
 221 void SdrPageView::CompleteRedraw(
 222     SdrPaintWindow& rPaintWindow, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector )
 223 {
 224     if(!GetPage())
 225         return;
 226
 227     SdrPageWindow* pPageWindow = FindPageWindow(rPaintWindow);
 228     std::unique_ptr<SdrPageWindow> pTempPageWindow;
 229
 230     if(!pPageWindow)
 231     {
 232         // create temp PageWindow
 233         pTempPageWindow.reset(new SdrPageWindow(*this, rPaintWindow));
 234         pPageWindow = pTempPageWindow.get();
 235     }
 236
 237     // do the redraw
 238     pPageWindow->PrepareRedraw(rReg);
 239     pPageWindow->RedrawAll(pRedirector);
 240 }
 241
 242
 243 // #i74769# use SdrPaintWindow directly
 244
 245 void SdrPageView::setPreparedPageWindow(SdrPageWindow* pKnownTarget)
 246 {
 247     // #i72752# remember prepared SdrPageWindow
 248     mpPreparedPageWindow = pKnownTarget;
 249 }
 250
 251 void SdrPageView::DrawLayer(SdrLayerID nID, OutputDevice* pGivenTarget,
 252         sdr::contact::ViewObjectContactRedirector* pRedirector,
 253         const tools::Rectangle& rRect, basegfx::B2IRectangle const*const pPageFrame)
 254 {
 255     if(!GetPage())
 256         return;
 257
 258     if(pGivenTarget)
 259     {
 260         SdrPageWindow* pKnownTarget = FindPageWindow(*pGivenTarget);
 261
 262         if(pKnownTarget)
 263         {
 264             // paint known target
 265             pKnownTarget->RedrawLayer(&nID, pRedirector, pPageFrame);
 266         }
 267         else
 268         {
 269             // #i72752# DrawLayer() uses an OutputDevice different from BeginDrawLayer. This happens
 270             // e.g. when SW paints a single text line in text edit mode. Try to use it
 271             SdrPageWindow* pPreparedTarget = mpPreparedPageWindow;
 272
 273             if(pPreparedTarget)
 274             {
 275                 // if we have a prepared target, do not use a new SdrPageWindow since this
 276                 // works but is expensive. Just use a temporary PaintWindow
 277                 SdrPaintWindow aTemporaryPaintWindow(mrView, *pGivenTarget);
 278
 279                 // Copy existing paint region to use the same as prepared in BeginDrawLayer
 280                 SdrPaintWindow& rExistingPaintWindow = pPreparedTarget->GetPaintWindow();
 281                 const vcl::Region& rExistingRegion = rExistingPaintWindow.GetRedrawRegion();
 282                 bool bUseRect(false);
 283                 if (!rRect.IsEmpty())
 284                 {
 285                     vcl::Region r(rExistingRegion);
 286                     r.Intersect(rRect);
 287                     // fdo#74435: FIXME: visibility check broken if empty
 288                     if (!r.IsEmpty())
 289                         bUseRect = true;
 290                 }
 291                 if (!bUseRect)
 292                     aTemporaryPaintWindow.SetRedrawRegion(rExistingRegion);
 293                 else
 294                     aTemporaryPaintWindow.SetRedrawRegion(vcl::Region(rRect));
 295
 296                 // patch the ExistingPageWindow
 297                 auto pPreviousWindow = pPreparedTarget->patchPaintWindow(aTemporaryPaintWindow);
 298                 // unpatch window when leaving the scope
 299                 const ::comphelper::ScopeGuard aGuard(
 300                     [&pPreviousWindow, &pPreparedTarget]() { pPreparedTarget->unpatchPaintWindow(pPreviousWindow); } );
 301                 // redraw the layer
 302                 pPreparedTarget->RedrawLayer(&nID, pRedirector, pPageFrame);
 303             }
 304             else
 305             {
 306                 OSL_FAIL("SdrPageView::DrawLayer: Creating temporary SdrPageWindow (ObjectContact), this should never be needed (!)");
 307
 308                 // None of the known OutputDevices is the target of this paint, use
 309                 // a temporary SdrPageWindow for this Redraw.
 310                 SdrPaintWindow aTemporaryPaintWindow(mrView, *pGivenTarget);
 311                 SdrPageWindow aTemporaryPageWindow(*this, aTemporaryPaintWindow);
 312
 313                 // #i72752#
 314                 // Copy existing paint region if other PageWindows exist, this was created by
 315                 // PrepareRedraw() from BeginDrawLayer(). Needs to be used e.g. when suddenly SW
 316                 // paints into an unknown device other than the view was created for (e.g. VirtualDevice)
 317                 if(PageWindowCount())
 318                 {
 319                     SdrPageWindow* pExistingPageWindow = GetPageWindow(0);
 320                     SdrPaintWindow& rExistingPaintWindow = pExistingPageWindow->GetPaintWindow();
 321                     const vcl::Region& rExistingRegion = rExistingPaintWindow.GetRedrawRegion();
 322                     aTemporaryPaintWindow.SetRedrawRegion(rExistingRegion);
 323                 }
 324
 325                 aTemporaryPageWindow.RedrawLayer(&nID, pRedirector, nullptr);
 326             }
 327         }
 328     }
 329     else
 330     {
 331         // paint in all known windows
 332         for(sal_uInt32 a(0); a < PageWindowCount(); a++)
 333         {
 334             SdrPageWindow* pTarget = GetPageWindow(a);
 335             pTarget->RedrawLayer(&nID, pRedirector, nullptr);
 336         }
 337     }
 338 }
 339
 340 void SdrPageView::SetDesignMode( bool _bDesignMode ) const
 341 {
 342     for ( sal_uInt32 i = 0; i < PageWindowCount(); ++i )
 343     {
 344         const SdrPageWindow& rPageViewWindow = *GetPageWindow(i);
 345         rPageViewWindow.SetDesignMode( _bDesignMode );
 346     }
 347 }
 348
 349
 350 void SdrPageView::DrawPageViewGrid(OutputDevice& rOut, const tools::Rectangle& rRect, Color aColor)
 351 {
 352     if (GetPage()==nullptr)
 353         return;
 354
 355     tools::Long nx1=GetView().maGridBig.Width();
 356     tools::Long nx2=GetView().maGridFin.Width();
 357     tools::Long ny1=GetView().maGridBig.Height();
 358     tools::Long ny2=GetView().maGridFin.Height();
 359
 360     if (nx1==0) nx1=nx2;
 361     if (nx2==0) nx2=nx1;
 362     if (ny1==0) ny1=ny2;
 363     if (ny2==0) ny2=ny1;
 364     if (nx1==0) { nx1=ny1; nx2=ny2; }
 365     if (ny1==0) { ny1=nx1; ny2=nx2; }
 366     if (nx1<0) nx1=-nx1;
 367     if (nx2<0) nx2=-nx2;
 368     if (ny1<0) ny1=-ny1;
 369     if (ny2<0) ny2=-ny2;
 370
 371     if (nx1==0)
 372         return;
 373
 374     // no more global output size, use window size instead to decide grid sizes
 375     tools::Long nScreenWdt = rOut.GetOutputSizePixel().Width();
 376
 377     tools::Long nMinDotPix=2;
 378     tools::Long nMinLinPix=4;
 379
 380     if (nScreenWdt>=1600)
 381     {
 382         nMinDotPix=4;
 383         nMinLinPix=8;
 384     }
 385     else if (nScreenWdt>=1024)
 386     {
 387         nMinDotPix=3;
 388         nMinLinPix=6;
 389     }
 390     else
 391     { // e. g. 640x480
 392         nMinDotPix=2;
 393         nMinLinPix=4;
 394     }
 395     Size aMinDotDist(rOut.PixelToLogic(Size(nMinDotPix,nMinDotPix)));
 396     Size aMinLinDist(rOut.PixelToLogic(Size(nMinLinPix,nMinLinPix)));
 397     bool bHoriSolid=nx2<aMinDotDist.Width();
 398     bool bVertSolid=ny2<aMinDotDist.Height();
 399     // enlarge line offset (minimum 4 pixels)
 400     // enlarge by: *2 *5 *10 *20 *50 *100 ...
 401     int nTgl=0;
 402     tools::Long nVal0=nx1;
 403     while (nx1<aMinLinDist.Width())
 404     {
 405         tools::Long a=nx1;
 406
 407         if (nTgl==0) nx1*=2;
 408         if (nTgl==1) nx1=nVal0*5; // => nx1*=2.5
 409         if (nTgl==2) nx1*=2;
 410
 411         nVal0=a;
 412         nTgl++; if (nTgl>=3) nTgl=0;
 413     }
 414     nTgl=0;
 415     nVal0=ny1;
 416     while (ny1<aMinLinDist.Height())
 417     {
 418         tools::Long a=ny1;
 419
 420         if (nTgl==0) ny1*=2;
 421         if (nTgl==1) ny1=nVal0*5; // => ny1*=2.5
 422         if (nTgl==2) ny1*=2;
 423
 424         nVal0=a;
 425         nTgl++;
 426
 427         if (nTgl>=3) nTgl=0;
 428     }
 429
 430     bool bHoriFine=nx2<nx1;
 431     bool bVertFine=ny2<ny1;
 432     bool bHoriLines=bHoriSolid || bHoriFine || !bVertFine;
 433     bool bVertLines=bVertSolid || bVertFine;
 434
 435     Color aOriginalLineColor( rOut.GetLineColor() );
 436     rOut.SetLineColor( aColor );
 437
 438     bool bMap0=rOut.IsMapModeEnabled();
 439
 440     tools::Long nWrX=0;
 441     tools::Long nWrY=0;
 442     Point aOrg(maPageOrigin);
 443     tools::Long x1 = 0;
 444     tools::Long x2 = 0;
 445     if (GetPage()->GetWidth() < 0) // ScDrawPage of RTL sheet
 446     {
 447         x1 = GetPage()->GetWidth() + GetPage()->GetLeftBorder() + 1;
 448         x2 = - GetPage()->GetRightBorder() - 1;
 449     }
 450     else
 451     {
 452         x1 = GetPage()->GetLeftBorder() + 1;
 453         x2 = GetPage()->GetWidth() - GetPage()->GetRightBorder() - 1;
 454     }
 455     tools::Long y1 = GetPage()->GetUpperBorder() + 1;
 456     tools::Long y2 = GetPage()->GetHeight() - GetPage()->GetLowerBorder() - 1;
 457     const SdrPageGridFrameList* pFrames=GetPage()->GetGridFrameList(this,nullptr);
 458
 459     sal_uInt16 nGridPaintCnt=1;
 460     if (pFrames!=nullptr) nGridPaintCnt=pFrames->GetCount();
 461     for (sal_uInt16 nGridPaintNum=0; nGridPaintNum<nGridPaintCnt; nGridPaintNum++) {
 462         if (pFrames!=nullptr) {
 463             const SdrPageGridFrame& rGF=(*pFrames)[nGridPaintNum];
 464             nWrX=rGF.GetPaperRect().Left();
 465             nWrY=rGF.GetPaperRect().Top();
 466             x1=rGF.GetUserArea().Left();
 467             x2=rGF.GetUserArea().Right();
 468             y1=rGF.GetUserArea().Top();
 469             y2=rGF.GetUserArea().Bottom();
 470             aOrg=rGF.GetUserArea().TopLeft();
 471             aOrg-=rGF.GetPaperRect().TopLeft();
 472         }
 473         if (!rRect.IsEmpty()) {
 474             Size a1PixSiz(rOut.PixelToLogic(Size(1,1)));
 475             tools::Long nX1Pix=a1PixSiz.Width();  // add 1 pixel of tolerance
 476             tools::Long nY1Pix=a1PixSiz.Height();
 477             if (x1<rRect.Left()  -nX1Pix) x1=rRect.Left()  -nX1Pix;
 478             if (x2>rRect.Right() +nX1Pix) x2=rRect.Right() +nX1Pix;
 479             if (y1<rRect.Top()   -nY1Pix) y1=rRect.Top()   -nY1Pix;
 480             if (y2>rRect.Bottom()+nY1Pix) y2=rRect.Bottom()+nY1Pix;
 481         }
 482
 483         tools::Long xBigOrg=aOrg.X()+nWrX;
 484         while (xBigOrg>=x1) xBigOrg-=nx1;
 485         while (xBigOrg<x1) xBigOrg+=nx1;
 486         tools::Long xFinOrg=xBigOrg;
 487         while (xFinOrg>=x1) xFinOrg-=nx2;
 488         while (xFinOrg<x1) xFinOrg+=nx2;
 489
 490         tools::Long yBigOrg=aOrg.Y()+nWrY;
 491         while (yBigOrg>=y1) yBigOrg-=ny1;
 492         while (yBigOrg<y1) yBigOrg+=ny1;
 493         tools::Long yFinOrg=yBigOrg;
 494         while (yFinOrg>=y1) yFinOrg-=ny2;
 495         while (yFinOrg<y1) yFinOrg+=ny2;
 496
 497         if( x1 <= x2 && y1 <= y2 )
 498         {
 499             if( bHoriLines )
 500             {
 501                 DrawGridFlags nGridFlags = ( bHoriSolid ? DrawGridFlags::HorzLines : DrawGridFlags::Dots );
 502                 sal_uInt16 nSteps = sal_uInt16(nx1 / nx2);
 503                 sal_uInt32 nRestPerStepMul1000 = nSteps ? ( ((nx1 * 1000)/ nSteps) - (nx2 * 1000) ) : 0;
 504                 sal_uInt32 nStepOffset = 0;
 505                 sal_uInt16 nPointOffset = 0;
 506
 507                 for(sal_uInt16 a=0;a<nSteps;a++)
 508                 {
 509                     // draw
 510                     rOut.DrawGrid(
 511                         tools::Rectangle( xFinOrg + (a * nx2) + nPointOffset, yBigOrg, x2, y2 ),
 512                         Size( nx1, ny1 ), nGridFlags );
 513
 514                     // do a step
 515                     nStepOffset += nRestPerStepMul1000;
 516                     while(nStepOffset >= 1000)
 517                     {
 518                         nStepOffset -= 1000;
 519                         nPointOffset++;
 520                     }
 521                 }
 522             }
 523
 524             if( bVertLines )
 525             {
 526                 DrawGridFlags nGridFlags = ( bVertSolid ? DrawGridFlags::VertLines : DrawGridFlags::Dots );
 527                 sal_uInt16 nSteps = sal_uInt16(ny1 / ny2);
 528                 sal_uInt32 nRestPerStepMul1000 = nSteps ? ( ((ny1 * 1000L)/ nSteps) - (ny2 * 1000L) ) : 0;
 529                 sal_uInt32 nStepOffset = 0;
 530                 sal_uInt16 nPointOffset = 0;
 531
 532                 for(sal_uInt16 a=0;a<nSteps;a++)
 533                 {
 534                     // draw
 535                     rOut.DrawGrid(
 536                         tools::Rectangle( xBigOrg, yFinOrg + (a * ny2) + nPointOffset, x2, y2 ),
 537                         Size( nx1, ny1 ), nGridFlags );
 538
 539                     // do a step
 540                     nStepOffset += nRestPerStepMul1000;
 541                     while(nStepOffset >= 1000)
 542                     {
 543                         nStepOffset -= 1000;
 544                         nPointOffset++;
 545                     }
 546                 }
 547             }
 548         }
 549     }
 550
 551     rOut.EnableMapMode(bMap0);
 552     rOut.SetLineColor(aOriginalLineColor);
 553 }
 554
 555 void SdrPageView::AdjHdl()
 556 {
 557     GetView().AdjustMarkHdl();
 558 }
 559
 560 void SdrPageView::SetLayer(const OUString& rName, SdrLayerIDSet& rBS, bool bJa)
 561 {
 562     if(!GetPage())
 563         return;
 564
 565     SdrLayerID nID = GetPage()->GetLayerAdmin().GetLayerID(rName);
 566
 567     if(SDRLAYER_NOTFOUND != nID)
 568         rBS.Set(nID, bJa);
 569 }
 570
 571 bool SdrPageView::IsLayer(const OUString& rName, const SdrLayerIDSet& rBS) const
 572 {
 573     if(!GetPage())
 574         return false;
 575
 576     bool bRet(false);
 577
 578     if (!rName.isEmpty())
 579     {
 580         SdrLayerID nId = GetPage()->GetLayerAdmin().GetLayerID(rName);
 581
 582         if(SDRLAYER_NOTFOUND != nId)
 583         {
 584             bRet = rBS.IsSet(nId);
 585         }
 586     }
 587
 588     return bRet;
 589 }
 590
 591 bool SdrPageView::IsObjMarkable(SdrObject const * pObj) const
 592 {
 593     if (!pObj)
 594         return false;
 595     if (pObj->IsMarkProtect())
 596         return false;    // excluded from selection?
 597     if (!pObj->IsVisible())
 598         return false;    // only visible are selectable
 599     if (!pObj->IsInserted())
 600         return false;    // Obj deleted?
 601     if (auto pObjGroup = dynamic_cast<const SdrObjGroup*>(pObj))
 602     {
 603         // If object is a Group object, visibility may depend on
 604         // multiple layers. If one object is markable, Group is markable.
 605         SdrObjList* pObjList = pObjGroup->GetSubList();
 606
 607         if (pObjList && pObjList->GetObjCount())
 608         {
 609             for (size_t a = 0; a < pObjList->GetObjCount(); ++a)
 610             {
 611                 SdrObject* pCandidate = pObjList->GetObj(a);
 612                 // call recursively
 613                 if (IsObjMarkable(pCandidate))
 614                     return true;
 615             }
 616             return false;
 617         }
 618         else
 619         {
 620             // #i43302#
 621             // Allow empty groups to be selected to be able to delete them
 622             return true;
 623         }
 624     }
 625     if (!pObj->Is3DObj() && pObj->getSdrPageFromSdrObject() != GetPage())
 626     {
 627         // Obj suddenly in different Page
 628         return false;
 629     }
 630
 631     // the layer has to be visible and must not be locked
 632     SdrLayerID nL = pObj->GetLayer();
 633     if (!aLayerVisi.IsSet(nL))
 634         return false;
 635     if (aLayerLock.IsSet(nL))
 636         return false;
 637     return true;
 638 }
 639
 640 void SdrPageView::SetPageOrigin(const Point& rOrg)
 641 {
 642     if (rOrg != maPageOrigin)
 643     {
 644         maPageOrigin = rOrg;
 645         if (GetView().IsGridVisible())
 646         {
 647             InvalidateAllWin();
 648         }
 649     }
 650 }
 651
 652 void SdrPageView::ImpInvalidateHelpLineArea(sal_uInt16 nNum) const
 653 {
 654     if (!(GetView().IsHlplVisible() && nNum<aHelpLines.GetCount()))        return;
 655
 656     const SdrHelpLine& rHL=aHelpLines[nNum];
 657
 658     for(sal_uInt32 a(0); a < GetView().PaintWindowCount(); a++)
 659     {
 660         SdrPaintWindow* pCandidate = GetView().GetPaintWindow(a);
 661
 662         if(pCandidate->OutputToWindow())
 663         {
 664             OutputDevice& rOutDev = pCandidate->GetOutputDevice();
 665             tools::Rectangle aR(rHL.GetBoundRect(rOutDev));
 666             Size aSiz(rOutDev.PixelToLogic(Size(1,1)));
 667             aR.AdjustLeft( -(aSiz.Width()) );
 668             aR.AdjustRight(aSiz.Width() );
 669             aR.AdjustTop( -(aSiz.Height()) );
 670             aR.AdjustBottom(aSiz.Height() );
 671             const_cast<SdrView&>(GetView()).InvalidateOneWin(rOutDev, aR);
 672         }
 673     }
 674 }
 675
 676 void SdrPageView::SetHelpLines(const SdrHelpLineList& rHLL)
 677 {
 678     aHelpLines=rHLL;
 679     InvalidateAllWin();
 680 }
 681
 682 void SdrPageView::SetHelpLine(sal_uInt16 nNum, const SdrHelpLine& rNewHelpLine)
 683 {
 684     if (nNum >= aHelpLines.GetCount() || aHelpLines[nNum] == rNewHelpLine)
 685         return;
 686
 687     bool bNeedRedraw = true;
 688     if (aHelpLines[nNum].GetKind()==rNewHelpLine.GetKind()) {
 689         switch (rNewHelpLine.GetKind()) {
 690             case SdrHelpLineKind::Vertical  : if (aHelpLines[nNum].GetPos().X()==rNewHelpLine.GetPos().X()) bNeedRedraw = false; break;
 691             case SdrHelpLineKind::Horizontal: if (aHelpLines[nNum].GetPos().Y()==rNewHelpLine.GetPos().Y()) bNeedRedraw = false; break;
 692             default: break;
 693         } // switch
 694     }
 695     if (bNeedRedraw) ImpInvalidateHelpLineArea(nNum);
 696     aHelpLines[nNum]=rNewHelpLine;
 697     if (bNeedRedraw) ImpInvalidateHelpLineArea(nNum);
 698 }
 699
 700 void SdrPageView::DeleteHelpLine(sal_uInt16 nNum)
 701 {
 702     if (nNum<aHelpLines.GetCount()) {
 703         ImpInvalidateHelpLineArea(nNum);
 704         aHelpLines.Delete(nNum);
 705     }
 706 }
 707
 708 void SdrPageView::InsertHelpLine(const SdrHelpLine& rHL)
 709 {
 710     sal_uInt16 nNum = aHelpLines.GetCount();
 711     aHelpLines.Insert(rHL,nNum);
 712     if (GetView().IsHlplVisible())
 713         ImpInvalidateHelpLineArea(nNum);
 714 }
 715
 716 // set current group and list
 717 void SdrPageView::SetCurrentGroupAndList(SdrObject* pNewGroup, SdrObjList* pNewList)
 718 {
 719     if(pCurrentGroup != pNewGroup)
 720     {
 721         pCurrentGroup = pNewGroup;
 722     }
 723     if(pCurrentList != pNewList)
 724     {
 725         pCurrentList = pNewList;
 726     }
 727 }
 728
 729 bool SdrPageView::EnterGroup(SdrObject* pObj)
 730 {
 731     if(!pObj || !pObj->IsGroupObject())
 732         return false;
 733
 734     // Don't allow enter Diagrams
 735     if(nullptr != pObj && pObj->isDiagram())
 736         return false;
 737
 738     const bool bGlueInvalidate(GetView().ImpIsGlueVisible());
 739
 740     if (bGlueInvalidate)
 741     {
 742         GetView().GlueInvalidate();
 743     }
 744
 745     // deselect all
 746     GetView().UnmarkAll();
 747
 748     // set current group and list
 749     SdrObjList* pNewObjList = pObj->GetSubList();
 750     SetCurrentGroupAndList(pObj, pNewObjList);
 751
 752     // select contained object if only one object is contained,
 753     // else select nothing and let the user decide what to do next
 754     if(pNewObjList && pNewObjList->GetObjCount() == 1)
 755     {
 756         SdrObject* pFirstObject = pNewObjList->GetObj(0);
 757
 758         if(GetView().GetSdrPageView())
 759         {
 760             GetView().MarkObj(pFirstObject, GetView().GetSdrPageView());
 761         }
 762     }
 763
 764     // build new handles
 765     GetView().AdjustMarkHdl();
 766
 767     // invalidate only when view wants to visualize group entering
 768     InvalidateAllWin();
 769
 770     if (bGlueInvalidate)
 771     {
 772         GetView().GlueInvalidate();
 773     }
 774
 775     return true;
 776 }
 777
 778 void SdrPageView::LeaveOneGroup()
 779 {
 780     SdrObject* pLastGroup = GetCurrentGroup();
 781     if (!pLastGroup)
 782         return;
 783
 784     bool bGlueInvalidate = GetView().ImpIsGlueVisible();
 785
 786     if(bGlueInvalidate)
 787         GetView().GlueInvalidate();
 788
 789     SdrObject* pParentGroup = pLastGroup->getParentSdrObjectFromSdrObject();
 790     SdrObjList* pParentList = GetPage();
 791
 792     if(pParentGroup)
 793         pParentList = pParentGroup->GetSubList();
 794
 795     // deselect everything
 796     GetView().UnmarkAll();
 797
 798     // allocations, pCurrentGroup and pCurrentList need to be set
 799     SetCurrentGroupAndList(pParentGroup, pParentList);
 800
 801     // select the group we just left
 802     if (GetView().GetSdrPageView())
 803         GetView().MarkObj(pLastGroup, GetView().GetSdrPageView());
 804
 805     GetView().AdjustMarkHdl();
 806
 807     // invalidate only if view wants to visualize group entering
 808     InvalidateAllWin();
 809
 810     if(bGlueInvalidate)
 811         GetView().GlueInvalidate();
 812 }
 813
 814 void SdrPageView::LeaveAllGroup()
 815 {
 816     SdrObject* pLastGroup = GetCurrentGroup();
 817     if (!pLastGroup)
 818         return;
 819
 820     bool bGlueInvalidate = GetView().ImpIsGlueVisible();
 821
 822     if(bGlueInvalidate)
 823         GetView().GlueInvalidate();
 824
 825     // deselect everything
 826     GetView().UnmarkAll();
 827
 828     // allocations, pCurrentGroup and pCurrentList always need to be set
 829     SetCurrentGroupAndList(nullptr, GetPage());
 830
 831     // find and select uppermost group
 832     while (pLastGroup->getParentSdrObjectFromSdrObject())
 833         pLastGroup = pLastGroup->getParentSdrObjectFromSdrObject();
 834
 835     if (GetView().GetSdrPageView())
 836         GetView().MarkObj(pLastGroup, GetView().GetSdrPageView());
 837
 838     GetView().AdjustMarkHdl();
 839
 840     // invalidate only when view wants to visualize group entering
 841     InvalidateAllWin();
 842
 843     if(bGlueInvalidate)
 844         GetView().GlueInvalidate();
 845 }
 846
 847 sal_uInt16 SdrPageView::GetEnteredLevel() const
 848 {
 849     sal_uInt16 nCount=0;
 850     SdrObject* pGrp=GetCurrentGroup();
 851     while (pGrp!=nullptr) {
 852         nCount++;
 853         pGrp=pGrp->getParentSdrObjectFromSdrObject();
 854     }
 855     return nCount;
 856 }
 857
 858 void SdrPageView::CheckCurrentGroup()
 859 {
 860     SdrObject* pGrp(GetCurrentGroup());
 861
 862     while(nullptr != pGrp &&
 863         (!pGrp->IsInserted() || nullptr == pGrp->getParentSdrObjListFromSdrObject() || nullptr == pGrp->getSdrPageFromSdrObject()))
 864     {
 865         // anything outside of the borders?
 866         pGrp = pGrp->getParentSdrObjectFromSdrObject();
 867     }
 868
 869     if(pGrp != GetCurrentGroup())
 870     {
 871         if(nullptr != pGrp)
 872         {
 873             EnterGroup(pGrp);
 874         }
 875         else
 876         {
 877             LeaveAllGroup();
 878         }
 879     }
 880 }
 881
 882 // Set background color for svx at SdrPageViews
 883 void SdrPageView::SetApplicationBackgroundColor(Color aBackgroundColor)
 884 {
 885     maBackgroundColor = aBackgroundColor;
 886 }
 887
 888
 889 // Set document color for svx at SdrPageViews
 890 void SdrPageView::SetApplicationDocumentColor(Color aDocumentColor)
 891 {
 892     maDocumentColor = aDocumentColor;
 893 }
 894
 895
 896 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */