LCOV - code coverage report
Current view: top level - svx/source/sdr/contact - viewobjectcontactofsdrpage.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 235 270 87.0 %
Date: 2015-06-13 12:38:46 Functions: 51 52 98.1 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      21             : #include <sdr/contact/viewobjectcontactofsdrpage.hxx>
      22             : #include <svx/sdr/contact/displayinfo.hxx>
      23             : #include <sdr/contact/viewcontactofsdrpage.hxx>
      24             : #include <svx/svdview.hxx>
      25             : #include <svx/svdpage.hxx>
      26             : #include <svx/sdr/contact/objectcontact.hxx>
      27             : #include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx>
      28             : #include <basegfx/polygon/b2dpolygontools.hxx>
      29             : #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
      30             : #include <drawinglayer/primitive2d/gridprimitive2d.hxx>
      31             : #include <drawinglayer/primitive2d/helplineprimitive2d.hxx>
      32             : #include <basegfx/polygon/b2dpolygon.hxx>
      33             : #include <sdr/primitive2d/sdrprimitivetools.hxx>
      34             : 
      35             : using namespace com::sun::star;
      36             : 
      37             : namespace sdr { namespace contact {
      38             : 
      39        2929 : const SdrPage& ViewObjectContactOfPageSubObject::getPage() const
      40             : {
      41        2929 :     return static_cast< ViewContactOfPageSubObject& >(GetViewContact()).getPage();
      42             : }
      43             : 
      44       31001 : ViewObjectContactOfPageSubObject::ViewObjectContactOfPageSubObject(ObjectContact& rObjectContact, ViewContact& rViewContact)
      45       31001 : :   ViewObjectContact(rObjectContact, rViewContact)
      46             : {
      47       31001 : }
      48             : 
      49       30803 : ViewObjectContactOfPageSubObject::~ViewObjectContactOfPageSubObject()
      50             : {
      51       30803 : }
      52             : 
      53      416566 : bool ViewObjectContactOfPageSubObject::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
      54             : {
      55      416566 :     if(rDisplayInfo.GetSubContentActive())
      56             :     {
      57       10420 :         return false;
      58             :     }
      59             : 
      60      406146 :     if(rDisplayInfo.GetControlLayerProcessingActive())
      61             :     {
      62      142358 :         return false;
      63             :     }
      64             : 
      65      263788 :     if(!rDisplayInfo.GetPageProcessingActive())
      66             :     {
      67      245810 :         return false;
      68             :     }
      69             : 
      70       17978 :     if(GetObjectContact().isOutputToPrinter())
      71             :     {
      72           0 :         return false;
      73             :     }
      74             : 
      75       17978 :     if(!GetObjectContact().TryToGetSdrPageView())
      76             :     {
      77           0 :         return false;
      78             :     }
      79             : 
      80       17978 :     return true;
      81             : }
      82             : 
      83        4538 : bool ViewObjectContactOfPageSubObject::isPrimitiveGhosted(const DisplayInfo& /*rDisplayInfo*/) const
      84             : {
      85             :     // suppress ghosted for page parts
      86        4538 :     return false;
      87             : }
      88             : 
      89        2843 : ViewObjectContactOfPageBackground::ViewObjectContactOfPageBackground(ObjectContact& rObjectContact, ViewContact& rViewContact)
      90        2843 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
      91             : {
      92        2843 : }
      93             : 
      94        5650 : ViewObjectContactOfPageBackground::~ViewObjectContactOfPageBackground()
      95             : {
      96        5650 : }
      97             : 
      98       41865 : bool ViewObjectContactOfPageBackground::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
      99             : {
     100       41865 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     101             :     {
     102       39963 :         return false;
     103             :     }
     104             : 
     105             :     // no page background for preview renderers
     106        1902 :     if(GetObjectContact().IsPreviewRenderer())
     107             :     {
     108         145 :         return false;
     109             :     }
     110             : 
     111        1757 :     return true;
     112             : }
     113             : 
     114        2164 : drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageBackground::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
     115             : {
     116             :     // Initialize background. Dependent of IsPageVisible, use ApplicationBackgroundColor or ApplicationDocumentColor. Most
     117             :     // old renderers for export (html, pdf, gallery, ...) set the page to not visible (SetPageVisible(false)). They expect the
     118             :     // given OutputDevice to be initialized with the ApplicationDocumentColor then.
     119        2164 :     const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
     120        2164 :     drawinglayer::primitive2d::Primitive2DSequence xRetval;
     121             : 
     122        2164 :     if(pPageView)
     123             :     {
     124        2164 :         const SdrView& rView = pPageView->GetView();
     125        2164 :         Color aInitColor;
     126             : 
     127        2164 :         if(rView.IsPageVisible())
     128             :         {
     129        1026 :             aInitColor = pPageView->GetApplicationBackgroundColor();
     130             :         }
     131             :         else
     132             :         {
     133        1138 :             aInitColor = pPageView->GetApplicationDocumentColor();
     134             : 
     135        1138 :             if(Color(COL_AUTO) == aInitColor)
     136             :             {
     137        1138 :                 const svtools::ColorConfig aColorConfig;
     138        1138 :                 aInitColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;
     139             :             }
     140             :         }
     141             : 
     142             :         // init background with InitColor
     143        2164 :         xRetval.realloc(1);
     144        2164 :         const basegfx::BColor aRGBColor(aInitColor.getBColor());
     145        2164 :         xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::BackgroundColorPrimitive2D(aRGBColor));
     146             :     }
     147             : 
     148        2164 :     return xRetval;
     149             : }
     150             : 
     151        2571 : ViewObjectContactOfMasterPage::ViewObjectContactOfMasterPage(ObjectContact& rObjectContact, ViewContact& rViewContact)
     152        2571 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     153             : {
     154        2571 : }
     155             : 
     156        5106 : ViewObjectContactOfMasterPage::~ViewObjectContactOfMasterPage()
     157             : {
     158        5106 : }
     159             : 
     160       39781 : bool ViewObjectContactOfMasterPage::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     161             : {
     162       39781 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     163             :     {
     164       38921 :         return false;
     165             :     }
     166             : 
     167             :     // this object is only used for MasterPages. When not the MasterPage is
     168             :     // displayed as a page, but another page is using it as sub-object, the
     169             :     // geometry needs to be hidden
     170         860 :     if(rDisplayInfo.GetSubContentActive())
     171             :     {
     172           0 :         return false;
     173             :     }
     174             : 
     175         860 :     return true;
     176             : }
     177             : 
     178        2843 : ViewObjectContactOfPageFill::ViewObjectContactOfPageFill(ObjectContact& rObjectContact, ViewContact& rViewContact)
     179        2843 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     180             : {
     181        2843 : }
     182             : 
     183        5650 : ViewObjectContactOfPageFill::~ViewObjectContactOfPageFill()
     184             : {
     185        5650 : }
     186             : 
     187       41865 : bool ViewObjectContactOfPageFill::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     188             : {
     189       41865 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     190             :     {
     191       39963 :         return false;
     192             :     }
     193             : 
     194        1902 :     SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
     195             : 
     196        1902 :     if(!pSdrPageView)
     197             :     {
     198           0 :         return false;
     199             :     }
     200             : 
     201        1902 :     if(!pSdrPageView->GetView().IsPageVisible())
     202             :     {
     203        1064 :         return false;
     204             :     }
     205             : 
     206         838 :     return true;
     207             : }
     208             : 
     209        1245 : drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageFill::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
     210             : {
     211        1245 :     const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
     212        1245 :     drawinglayer::primitive2d::Primitive2DSequence xRetval;
     213             : 
     214        1245 :     if(pPageView)
     215             :     {
     216        1245 :         const SdrPage& rPage = getPage();
     217             : 
     218        1245 :         const basegfx::B2DRange aPageFillRange(0.0, 0.0, (double)rPage.GetWdt(), (double)rPage.GetHgt());
     219        1245 :         const basegfx::B2DPolygon aPageFillPolygon(basegfx::tools::createPolygonFromRect(aPageFillRange));
     220        1245 :         Color aPageFillColor;
     221             : 
     222        1245 :         if(pPageView->GetApplicationDocumentColor() != COL_AUTO)
     223             :         {
     224           0 :             aPageFillColor = pPageView->GetApplicationDocumentColor();
     225             :         }
     226             :         else
     227             :         {
     228        1245 :             const svtools::ColorConfig aColorConfig;
     229        1245 :             aPageFillColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;
     230             :         }
     231             : 
     232             :         // create and add primitive
     233        1245 :         xRetval.realloc(1);
     234        2490 :         const basegfx::BColor aRGBColor(aPageFillColor.getBColor());
     235        2490 :         xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPageFillPolygon), aRGBColor));
     236             :     }
     237             : 
     238        1245 :     return xRetval;
     239             : }
     240             : 
     241        2843 : ViewObjectContactOfPageShadow::ViewObjectContactOfPageShadow(ObjectContact& rObjectContact, ViewContact& rViewContact)
     242        2843 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     243             : {
     244        2843 : }
     245             : 
     246        5650 : ViewObjectContactOfPageShadow::~ViewObjectContactOfPageShadow()
     247             : {
     248        5650 : }
     249             : 
     250       41865 : bool ViewObjectContactOfPageShadow::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     251             : {
     252       41865 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     253             :     {
     254       39963 :         return false;
     255             :     }
     256             : 
     257        1902 :     SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
     258             : 
     259        1902 :     if(!pSdrPageView)
     260             :     {
     261           0 :         return false;
     262             :     }
     263             : 
     264        1902 :     if(!pSdrPageView->GetView().IsPageVisible())
     265             :     {
     266        1064 :         return false;
     267             :     }
     268             : 
     269             :     // no page shadow for preview renderers
     270         838 :     if(GetObjectContact().IsPreviewRenderer())
     271             :     {
     272           0 :         return false;
     273             :     }
     274             : 
     275             :     // no page shadow for high contrast mode
     276         838 :     if(GetObjectContact().isDrawModeHighContrast())
     277             :     {
     278           0 :         return false;
     279             :     }
     280             : 
     281         838 :     return true;
     282             : }
     283             : 
     284        2843 : ViewObjectContactOfOuterPageBorder::ViewObjectContactOfOuterPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact)
     285        2843 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     286             : {
     287        2843 : }
     288             : 
     289        5650 : ViewObjectContactOfOuterPageBorder::~ViewObjectContactOfOuterPageBorder()
     290             : {
     291        5650 : }
     292             : 
     293       41865 : bool ViewObjectContactOfOuterPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     294             : {
     295       41865 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     296             :     {
     297       39963 :         return false;
     298             :     }
     299             : 
     300        1902 :     SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
     301             : 
     302        1902 :     if(!pSdrPageView)
     303             :     {
     304           0 :         return false;
     305             :     }
     306             : 
     307        1902 :     const SdrView& rView = pSdrPageView->GetView();
     308             : 
     309        1902 :     if(!rView.IsPageVisible() && rView.IsPageBorderVisible())
     310             :     {
     311         217 :         return false;
     312             :     }
     313             : 
     314        1685 :     return true;
     315             : }
     316             : 
     317        2843 : ViewObjectContactOfInnerPageBorder::ViewObjectContactOfInnerPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact)
     318        2843 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     319             : {
     320        2843 : }
     321             : 
     322        5650 : ViewObjectContactOfInnerPageBorder::~ViewObjectContactOfInnerPageBorder()
     323             : {
     324        5650 : }
     325             : 
     326       41865 : bool ViewObjectContactOfInnerPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     327             : {
     328       41865 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     329             :     {
     330       39963 :         return false;
     331             :     }
     332             : 
     333        1902 :     SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
     334             : 
     335        1902 :     if(!pSdrPageView)
     336             :     {
     337           0 :         return false;
     338             :     }
     339             : 
     340        1902 :     if(!pSdrPageView->GetView().IsBordVisible())
     341             :     {
     342        1064 :         return false;
     343             :     }
     344             : 
     345         838 :     const SdrPage& rPage = getPage();
     346             : 
     347         838 :     if(!rPage.GetLftBorder() && !rPage.GetUppBorder() && !rPage.GetRgtBorder() && !rPage.GetLwrBorder())
     348             :     {
     349          44 :         return false;
     350             :     }
     351             : 
     352             :     // no inner page border for preview renderers
     353         794 :     if(GetObjectContact().IsPreviewRenderer())
     354             :     {
     355           0 :         return false;
     356             :     }
     357             : 
     358         794 :     return true;
     359             : }
     360             : 
     361        2843 : ViewObjectContactOfPageHierarchy::ViewObjectContactOfPageHierarchy(ObjectContact& rObjectContact, ViewContact& rViewContact)
     362        2843 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     363             : {
     364        2843 : }
     365             : 
     366        5650 : ViewObjectContactOfPageHierarchy::~ViewObjectContactOfPageHierarchy()
     367             : {
     368        5650 : }
     369             : 
     370       41865 : drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageHierarchy::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const
     371             : {
     372       41865 :     drawinglayer::primitive2d::Primitive2DSequence xRetval;
     373             : 
     374             :     // process local sub-hierarchy
     375       41865 :     const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
     376             : 
     377       41865 :     if(nSubHierarchyCount)
     378             :     {
     379       18095 :         xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo);
     380             : 
     381       18095 :         if(xRetval.hasElements())
     382             :         {
     383             :             // get ranges
     384        5934 :             const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D());
     385        5934 :             const basegfx::B2DRange aObjectRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xRetval, rViewInformation2D));
     386        5934 :             const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport());
     387             : 
     388             :             // check geometrical visibility
     389        5934 :             if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange))
     390             :             {
     391             :                 // not visible, release
     392           0 :                 xRetval.realloc(0);
     393             :             }
     394             :         }
     395             :     }
     396             : 
     397       41865 :     return xRetval;
     398             : }
     399             : 
     400        5686 : ViewObjectContactOfPageGrid::ViewObjectContactOfPageGrid(ObjectContact& rObjectContact, ViewContact& rViewContact)
     401        5686 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     402             : {
     403        5686 : }
     404             : 
     405       11300 : ViewObjectContactOfPageGrid::~ViewObjectContactOfPageGrid()
     406             : {
     407       11300 : }
     408             : 
     409       83730 : bool ViewObjectContactOfPageGrid::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     410             : {
     411       83730 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     412             :     {
     413       79926 :         return false;
     414             :     }
     415             : 
     416        3804 :     SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
     417             : 
     418        3804 :     if(!pSdrPageView)
     419             :     {
     420           0 :         return false;
     421             :     }
     422             : 
     423        3804 :     const SdrView& rView = pSdrPageView->GetView();
     424             : 
     425        3804 :     if(!rView.IsGridVisible())
     426             :     {
     427        3792 :         return false;
     428             :     }
     429             : 
     430             :     // no page grid for preview renderers
     431          12 :     if(GetObjectContact().IsPreviewRenderer())
     432             :     {
     433           0 :         return false;
     434             :     }
     435             : 
     436          12 :     if(static_cast< ViewContactOfGrid& >(GetViewContact()).getFront() != (bool)rView.IsGridFront())
     437             :     {
     438           6 :         return false;
     439             :     }
     440             : 
     441           6 :     return true;
     442             : }
     443             : 
     444         846 : drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageGrid::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
     445             : {
     446         846 :     const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
     447         846 :     drawinglayer::primitive2d::Primitive2DSequence xRetval;
     448             : 
     449         846 :     if(pPageView)
     450             :     {
     451         846 :         const SdrView& rView = pPageView->GetView();
     452         846 :         const SdrPage& rPage = getPage();
     453         846 :         const Color aGridColor(rView.GetGridColor());
     454         846 :         const basegfx::BColor aRGBGridColor(aGridColor.getBColor());
     455             : 
     456        1692 :         basegfx::B2DHomMatrix aGridMatrix;
     457         846 :         aGridMatrix.set(0, 0, (double)(rPage.GetWdt() - (rPage.GetRgtBorder() + rPage.GetLftBorder())));
     458         846 :         aGridMatrix.set(1, 1, (double)(rPage.GetHgt() - (rPage.GetLwrBorder() + rPage.GetUppBorder())));
     459         846 :         aGridMatrix.set(0, 2, (double)rPage.GetLftBorder());
     460         846 :         aGridMatrix.set(1, 2, (double)rPage.GetUppBorder());
     461             : 
     462         846 :         const Size aRaw(rView.GetGridCoarse());
     463         846 :         const Size aFine(rView.GetGridFine());
     464         846 :         const double fWidthX(aRaw.getWidth());
     465         846 :         const double fWidthY(aRaw.getHeight());
     466         846 :         const sal_uInt32 nSubdivisionsX(aFine.getWidth() ? aRaw.getWidth() / aFine.getWidth() : 0L);
     467         846 :         const sal_uInt32 nSubdivisionsY(aFine.getHeight() ? aRaw.getHeight() / aFine.getHeight() : 0L);
     468             : 
     469         846 :         xRetval.realloc(1);
     470        1692 :         xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::GridPrimitive2D(
     471             :             aGridMatrix, fWidthX, fWidthY, 10.0, 3.0, nSubdivisionsX, nSubdivisionsY, aRGBGridColor,
     472        3384 :             drawinglayer::primitive2d::createDefaultCross_3x3(aRGBGridColor)));
     473             :     }
     474             : 
     475         846 :     return xRetval;
     476             : }
     477             : 
     478        5686 : ViewObjectContactOfPageHelplines::ViewObjectContactOfPageHelplines(ObjectContact& rObjectContact, ViewContact& rViewContact)
     479        5686 : :   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
     480             : {
     481        5686 : }
     482             : 
     483       11300 : ViewObjectContactOfPageHelplines::~ViewObjectContactOfPageHelplines()
     484             : {
     485       11300 : }
     486             : 
     487       83730 : bool ViewObjectContactOfPageHelplines::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
     488             : {
     489       83730 :     if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
     490             :     {
     491       79926 :         return false;
     492             :     }
     493             : 
     494        3804 :     SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
     495             : 
     496        3804 :     if(!pSdrPageView)
     497             :     {
     498           0 :         return false;
     499             :     }
     500             : 
     501        3804 :     const SdrView& rView = pSdrPageView->GetView();
     502             : 
     503        3804 :     if(!rView.IsHlplVisible())
     504             :     {
     505        3792 :         return false;
     506             :     }
     507             : 
     508             :     // no helplines for preview renderers
     509          12 :     if(GetObjectContact().IsPreviewRenderer())
     510             :     {
     511           0 :         return false;
     512             :     }
     513             : 
     514          12 :     if(static_cast< ViewContactOfHelplines& >(GetViewContact()).getFront() != (bool)rView.IsHlplFront())
     515             :     {
     516           6 :         return false;
     517             :     }
     518             : 
     519           6 :     return true;
     520             : }
     521             : 
     522        1138 : drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageHelplines::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
     523             : {
     524        1138 :     drawinglayer::primitive2d::Primitive2DSequence xRetval;
     525        1138 :     const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
     526             : 
     527        1138 :     if(pPageView)
     528             :     {
     529        1138 :         const SdrHelpLineList& rHelpLineList = pPageView->GetHelpLines();
     530        1138 :         const sal_uInt32 nCount(rHelpLineList.GetCount());
     531             : 
     532        1138 :         if(nCount)
     533             :         {
     534           0 :             const basegfx::BColor aRGBColorA(1.0, 1.0, 1.0);
     535           0 :             const basegfx::BColor aRGBColorB(0.0, 0.0, 0.0);
     536           0 :             xRetval.realloc(nCount);
     537             : 
     538           0 :             for(sal_uInt32 a(0L); a < nCount; a++)
     539             :             {
     540           0 :                 const SdrHelpLine& rHelpLine = rHelpLineList[(sal_uInt16)a];
     541           0 :                 const basegfx::B2DPoint aPosition((double)rHelpLine.GetPos().X(), (double)rHelpLine.GetPos().Y());
     542           0 :                 const double fDiscreteDashLength(4.0);
     543             : 
     544           0 :                 switch(rHelpLine.GetKind())
     545             :                 {
     546             :                     default : // SDRHELPLINE_POINT
     547             :                     {
     548           0 :                         xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D(
     549             :                             aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HELPLINESTYLE2D_POINT,
     550           0 :                             aRGBColorA, aRGBColorB, fDiscreteDashLength));
     551           0 :                         break;
     552             :                     }
     553             :                     case SDRHELPLINE_VERTICAL :
     554             :                     {
     555           0 :                         xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D(
     556             :                             aPosition, basegfx::B2DVector(0.0, 1.0), drawinglayer::primitive2d::HELPLINESTYLE2D_LINE,
     557           0 :                             aRGBColorA, aRGBColorB, fDiscreteDashLength));
     558           0 :                         break;
     559             :                     }
     560             :                     case SDRHELPLINE_HORIZONTAL :
     561             :                     {
     562           0 :                         xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D(
     563             :                             aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HELPLINESTYLE2D_LINE,
     564           0 :                             aRGBColorA, aRGBColorB, fDiscreteDashLength));
     565           0 :                         break;
     566             :                     }
     567             :                 }
     568           0 :             }
     569             :         }
     570             :     }
     571             : 
     572        1138 :     return xRetval;
     573             : }
     574             : 
     575        2843 : ViewObjectContactOfSdrPage::ViewObjectContactOfSdrPage(ObjectContact& rObjectContact, ViewContact& rViewContact)
     576        2843 : :   ViewObjectContact(rObjectContact, rViewContact)
     577             : {
     578        2843 : }
     579             : 
     580        5650 : ViewObjectContactOfSdrPage::~ViewObjectContactOfSdrPage()
     581             : {
     582        5650 : }
     583             : 
     584       41865 : drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfSdrPage::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const
     585             : {
     586       41865 :     drawinglayer::primitive2d::Primitive2DSequence xRetval;
     587             : 
     588             :     // process local sub-hierarchy
     589       41865 :     const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
     590             : 
     591       41865 :     if(nSubHierarchyCount)
     592             :     {
     593             :         const bool bDoGhostedDisplaying(
     594       41865 :             GetObjectContact().DoVisualizeEnteredGroup()
     595       41865 :             && !GetObjectContact().isOutputToPrinter()
     596       83730 :             && GetObjectContact().getActiveViewContact() == &GetViewContact());
     597             : 
     598       41865 :         if(bDoGhostedDisplaying)
     599             :         {
     600       40823 :             rDisplayInfo.ClearGhostedDrawMode();
     601             :         }
     602             : 
     603             :         // create object hierarchy
     604       41865 :         xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo);
     605             : 
     606       41865 :         if(xRetval.hasElements())
     607             :         {
     608             :             // get ranges
     609        6218 :             const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D());
     610        6218 :             const basegfx::B2DRange aObjectRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xRetval, rViewInformation2D));
     611        6218 :             const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport());
     612             : 
     613             :             // check geometrical visibility
     614        6218 :             if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange))
     615             :             {
     616             :                 // not visible, release
     617           0 :                 xRetval.realloc(0);
     618             :             }
     619             :         }
     620             : 
     621       41865 :         if(bDoGhostedDisplaying)
     622             :         {
     623       40823 :             rDisplayInfo.SetGhostedDrawMode();
     624             :         }
     625             :     }
     626             : 
     627       41865 :     return xRetval;
     628             : }
     629             : 
     630         435 : }}
     631             : 
     632             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11