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