LCOV - code coverage report
Current view: top level - svx/source/sdr/attribute - sdrallfillattributeshelper.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 64 84 76.2 %
Date: 2014-11-03 Functions: 13 13 100.0 %
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             : #include <svx/sdr/attribute/sdrallfillattributeshelper.hxx>
      20             : #include <svx/sdr/primitive2d/sdrattributecreator.hxx>
      21             : #include <svx/sdr/primitive2d/sdrdecompositiontools.hxx>
      22             : #include <basegfx/polygon/b2dpolygontools.hxx>
      23             : #include <basegfx/matrix/b2dhommatrix.hxx>
      24             : #include <basegfx/polygon/b2dpolygon.hxx>
      25             : #include <drawinglayer/attribute/fillhatchattribute.hxx>
      26             : #include <drawinglayer/attribute/sdrfillgraphicattribute.hxx>
      27             : #include <svx/xfillit0.hxx>
      28             : #include <vcl/graph.hxx>
      29             : 
      30             : //////////////////////////////////////////////////////////////////////////////
      31             : 
      32             : namespace drawinglayer
      33             : {
      34             :     namespace attribute
      35             :     {
      36         676 :         void SdrAllFillAttributesHelper::createPrimitive2DSequence(
      37             :             const basegfx::B2DRange& rPaintRange,
      38             :             const basegfx::B2DRange& rDefineRange)
      39             :         {
      40             :             // reset and remember new target range for object geometry
      41         676 :             maLastPaintRange = rPaintRange;
      42         676 :             maLastDefineRange = rDefineRange;
      43             : 
      44         676 :             if(isUsed())
      45             :             {
      46         676 :                 maPrimitives.realloc(1);
      47        2938 :                 maPrimitives[0] = drawinglayer::primitive2d::createPolyPolygonFillPrimitive(
      48             :                     basegfx::B2DPolyPolygon(
      49             :                         basegfx::tools::createPolygonFromRect(
      50             :                             maLastPaintRange)),
      51             :                         maLastDefineRange,
      52        1352 :                     maFillAttribute.get() ? *maFillAttribute.get() : drawinglayer::attribute::SdrFillAttribute(),
      53        1586 :                     maFillGradientAttribute.get() ? *maFillGradientAttribute.get() : drawinglayer::attribute::FillGradientAttribute());
      54             :             }
      55         676 :         }
      56             : 
      57         456 :         SdrAllFillAttributesHelper::SdrAllFillAttributesHelper(const Color& rColor)
      58             :         :   maLastPaintRange(),
      59             :             maLastDefineRange(),
      60             :             maFillAttribute(),
      61             :             maFillGradientAttribute(),
      62         456 :             maPrimitives()
      63             :         {
      64             :             maFillAttribute.reset(
      65             :                 new drawinglayer::attribute::SdrFillAttribute(
      66             :                     0.0,
      67             :                     Color(rColor.GetRGBColor()).getBColor(),
      68             :                     drawinglayer::attribute::FillGradientAttribute(),
      69             :                     drawinglayer::attribute::FillHatchAttribute(),
      70         456 :                     drawinglayer::attribute::SdrFillGraphicAttribute()));
      71         456 :         }
      72             : 
      73       70438 :         SdrAllFillAttributesHelper::SdrAllFillAttributesHelper(const SfxItemSet& rSet)
      74             :         :   maLastPaintRange(),
      75             :             maLastDefineRange(),
      76             :             maFillAttribute(
      77             :                 new drawinglayer::attribute::SdrFillAttribute(
      78           0 :                     drawinglayer::primitive2d::createNewSdrFillAttribute(rSet))),
      79             :             maFillGradientAttribute(
      80             :                 new drawinglayer::attribute::FillGradientAttribute(
      81           0 :                     drawinglayer::primitive2d::createNewTransparenceGradientAttribute(rSet))),
      82       70438 :             maPrimitives()
      83             :         {
      84       70438 :         }
      85             : 
      86       70880 :         SdrAllFillAttributesHelper::~SdrAllFillAttributesHelper()
      87             :         {
      88       70880 :         }
      89             : 
      90      399567 :         bool SdrAllFillAttributesHelper::isUsed() const
      91             :         {
      92             :             // only depends on fill, FillGradientAttribute alone defines no fill
      93      399567 :             return maFillAttribute.get() && !maFillAttribute->isDefault();
      94             :         }
      95             : 
      96       14707 :         bool SdrAllFillAttributesHelper::isTransparent() const
      97             :         {
      98       14707 :             if(hasSdrFillAttribute() && 0.0 != maFillAttribute->getTransparence())
      99             :             {
     100       11692 :                 return true;
     101             :             }
     102             : 
     103        3015 :             if(hasFillGradientAttribute() && !maFillGradientAttribute->isDefault())
     104             :             {
     105           0 :                 return true;
     106             :             }
     107             : 
     108        3015 :             if(hasSdrFillAttribute())
     109             :             {
     110        3015 :                 const Graphic& rGraphic = getFillAttribute().getFillGraphic().getFillGraphic();
     111             : 
     112        3015 :                 return rGraphic.IsSupportedGraphic() && rGraphic.IsTransparent();
     113             :             }
     114             : 
     115           0 :             return false;
     116             :         }
     117             : 
     118        5507 :         const drawinglayer::attribute::SdrFillAttribute& SdrAllFillAttributesHelper::getFillAttribute() const
     119             :         {
     120        5507 :             if(!maFillAttribute.get())
     121             :             {
     122           0 :                 const_cast< SdrAllFillAttributesHelper* >(this)->maFillAttribute.reset(new drawinglayer::attribute::SdrFillAttribute());
     123             :             }
     124             : 
     125        5507 :             return *maFillAttribute.get();
     126             :         }
     127             : 
     128          28 :         const drawinglayer::attribute::FillGradientAttribute& SdrAllFillAttributesHelper::getFillGradientAttribute() const
     129             :         {
     130          28 :             if(!maFillGradientAttribute.get())
     131             :             {
     132           0 :                 const_cast< SdrAllFillAttributesHelper* >(this)->maFillGradientAttribute.reset(new drawinglayer::attribute::FillGradientAttribute());
     133             :             }
     134             : 
     135          28 :             return *maFillGradientAttribute.get();
     136             :         }
     137             : 
     138         746 :         const drawinglayer::primitive2d::Primitive2DSequence& SdrAllFillAttributesHelper::getPrimitive2DSequence(
     139             :             const basegfx::B2DRange& rPaintRange,
     140             :             const basegfx::B2DRange& rDefineRange) const
     141             :         {
     142         746 :             if(maPrimitives.getLength() && (maLastPaintRange != rPaintRange || maLastDefineRange != rDefineRange))
     143             :             {
     144          20 :                 const_cast< SdrAllFillAttributesHelper* >(this)->maPrimitives.realloc(0);
     145             :             }
     146             : 
     147         746 :             if(!maPrimitives.getLength())
     148             :             {
     149         676 :                 const_cast< SdrAllFillAttributesHelper* >(this)->createPrimitive2DSequence(rPaintRange, rDefineRange);
     150             :             }
     151             : 
     152         746 :             return maPrimitives;
     153             :         }
     154             : 
     155          28 :         basegfx::BColor SdrAllFillAttributesHelper::getAverageColor(const basegfx::BColor& rFallback) const
     156             :         {
     157          28 :             basegfx::BColor aRetval(rFallback);
     158             : 
     159          28 :             if(maFillAttribute.get() && !maFillAttribute->isDefault())
     160             :             {
     161          28 :                 const drawinglayer::attribute::FillGradientAttribute& rFillGradientAttribute = maFillAttribute->getGradient();
     162          28 :                 const drawinglayer::attribute::FillHatchAttribute& rFillHatchAttribute = maFillAttribute->getHatch();
     163          28 :                 const drawinglayer::attribute::SdrFillGraphicAttribute& rSdrFillGraphicAttribute = maFillAttribute->getFillGraphic();
     164          28 :                 const drawinglayer::attribute::FillGradientAttribute& rFillTransparenceGradientAttribute = getFillGradientAttribute();
     165          28 :                 double fTransparence(maFillAttribute->getTransparence());
     166             : 
     167          28 :                 if(!rFillTransparenceGradientAttribute.isDefault())
     168             :                 {
     169           0 :                     const double fTransA = rFillTransparenceGradientAttribute.getStartColor().luminance();
     170           0 :                     const double fTransB = rFillTransparenceGradientAttribute.getEndColor().luminance();
     171             : 
     172           0 :                     fTransparence = (fTransA + fTransB) * 0.5;
     173             :                 }
     174             : 
     175          28 :                 if(!rFillGradientAttribute.isDefault())
     176             :                 {
     177             :                     // gradient fill
     178           0 :                     const basegfx::BColor& rStart = rFillGradientAttribute.getStartColor();
     179           0 :                     const basegfx::BColor& rEnd = rFillGradientAttribute.getEndColor();
     180             : 
     181           0 :                     aRetval = basegfx::interpolate(rStart, rEnd, 0.5);
     182             :                 }
     183          28 :                 else if(!rFillHatchAttribute.isDefault())
     184             :                 {
     185             :                     // hatch fill
     186           0 :                     const basegfx::BColor& rColor = rFillHatchAttribute.getColor();
     187             : 
     188           0 :                     if(rFillHatchAttribute.isFillBackground())
     189             :                     {
     190           0 :                         const basegfx::BColor& rBackgroundColor = maFillAttribute->getColor();
     191             : 
     192             :                         // mix colors 50%/50%
     193           0 :                         aRetval = basegfx::interpolate(rColor, rBackgroundColor, 0.5);
     194             :                     }
     195             :                     else
     196             :                     {
     197             :                         // mix color with fallback color
     198           0 :                         aRetval = basegfx::interpolate(rColor, rFallback, 0.5);
     199             :                     }
     200             :                 }
     201          28 :                 else if(!rSdrFillGraphicAttribute.isDefault())
     202             :                 {
     203             :                     // graphic fill
     204             : 
     205             :                     // not used yet by purpose (see SwPageFrm::GetDrawBackgrdColor()),
     206             :                     // use fallback (already set)
     207             :                 }
     208             :                 else
     209             :                 {
     210             :                     // color fill
     211          28 :                     aRetval = maFillAttribute->getColor();
     212             :                 }
     213             : 
     214          28 :                 if(!basegfx::fTools::equalZero(fTransparence))
     215             :                 {
     216             :                     // blend into transparency
     217           0 :                     aRetval = basegfx::interpolate(aRetval, rFallback, fTransparence);
     218             :                 }
     219             :             }
     220             : 
     221          28 :             return aRetval.clamp();
     222             :         }
     223             : 
     224        2492 :         bool SdrAllFillAttributesHelper::needCompleteRepaint() const
     225             :         {
     226        2492 :             if(!isUsed() || !hasSdrFillAttribute())
     227             :             {
     228             :                 // not used or no fill
     229           0 :                 return false;
     230             :             }
     231             : 
     232        2492 :             const drawinglayer::attribute::SdrFillAttribute& rSdrFillAttribute = getFillAttribute();
     233             : 
     234        2492 :             if(!rSdrFillAttribute.getHatch().isDefault())
     235             :             {
     236             :                 // hatch is always top-left aligned, needs no full refreshes
     237           0 :                 return false;
     238             :             }
     239             : 
     240        2492 :             if(!rSdrFillAttribute.getGradient().isDefault())
     241             :             {
     242             :                 // gradients always scale with the object
     243          38 :                 return true;
     244             :             }
     245             : 
     246        2454 :             if(!rSdrFillAttribute.getFillGraphic().isDefault())
     247             :             {
     248             :                 // some graphic constellations may not need this, but since most do
     249             :                 // (stretch to fill, all but top-left aligned, ...) claim to do by default
     250           2 :                 return true;
     251             :             }
     252             : 
     253             :             // color fill
     254        2452 :             return false;
     255             :         }
     256             :     } // end of namespace attribute
     257         651 : } // end of namespace drawinglayer
     258             : 
     259             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10