LCOV - code coverage report
Current view: top level - drawinglayer/source/attribute - fillgradientattribute.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 60 60 100.0 %
Date: 2015-06-13 12:38:46 Functions: 28 28 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             : 
      20             : #include <drawinglayer/attribute/fillgradientattribute.hxx>
      21             : #include <basegfx/color/bcolor.hxx>
      22             : #include <rtl/instance.hxx>
      23             : 
      24             : 
      25             : 
      26             : namespace drawinglayer
      27             : {
      28             :     namespace attribute
      29             :     {
      30       22087 :         class ImpFillGradientAttribute
      31             :         {
      32             :         public:
      33             :             // data definitions
      34             :             GradientStyle                           meStyle;
      35             :             double                                  mfBorder;
      36             :             double                                  mfOffsetX;
      37             :             double                                  mfOffsetY;
      38             :             double                                  mfAngle;
      39             :             basegfx::BColor                         maStartColor;
      40             :             basegfx::BColor                         maEndColor;
      41             :             sal_uInt16                              mnSteps;
      42             : 
      43        7346 :             ImpFillGradientAttribute(
      44             :                 GradientStyle eStyle,
      45             :                 double fBorder,
      46             :                 double fOffsetX,
      47             :                 double fOffsetY,
      48             :                 double fAngle,
      49             :                 const basegfx::BColor& rStartColor,
      50             :                 const basegfx::BColor& rEndColor,
      51             :                 sal_uInt16 nSteps)
      52             :             :   meStyle(eStyle),
      53             :                 mfBorder(fBorder),
      54             :                 mfOffsetX(fOffsetX),
      55             :                 mfOffsetY(fOffsetY),
      56             :                 mfAngle(fAngle),
      57             :                 maStartColor(rStartColor),
      58             :                 maEndColor(rEndColor),
      59        7346 :                 mnSteps(nSteps)
      60             :             {
      61        7346 :             }
      62             : 
      63          87 :             ImpFillGradientAttribute()
      64             :             :   meStyle(GRADIENTSTYLE_LINEAR),
      65             :                 mfBorder(0.0),
      66             :                 mfOffsetX(0.0),
      67             :                 mfOffsetY(0.0),
      68             :                 mfAngle(0.0),
      69             :                 maStartColor(basegfx::BColor()),
      70             :                 maEndColor(basegfx::BColor()),
      71          87 :                 mnSteps(0)
      72             :             {
      73          87 :             }
      74             : 
      75             :             // data read access
      76       10085 :             GradientStyle getStyle() const { return meStyle; }
      77        8320 :             double getBorder() const { return mfBorder; }
      78        6515 :             double getOffsetX() const { return mfOffsetX; }
      79        6515 :             double getOffsetY() const { return mfOffsetY; }
      80        8320 :             double getAngle() const { return mfAngle; }
      81        8625 :             const basegfx::BColor& getStartColor() const { return maStartColor; }
      82        8625 :             const basegfx::BColor& getEndColor() const { return maEndColor; }
      83        8320 :             sal_uInt16 getSteps() const { return mnSteps; }
      84             : 
      85        3253 :             bool operator==(const ImpFillGradientAttribute& rCandidate) const
      86             :             {
      87        3253 :                 return (getStyle() == rCandidate.getStyle()
      88        3253 :                     && getBorder() == rCandidate.getBorder()
      89        3253 :                     && getOffsetX() == rCandidate.getOffsetX()
      90        3253 :                     && getOffsetY() == rCandidate.getOffsetY()
      91        3253 :                     && getAngle() == rCandidate.getAngle()
      92        3253 :                     && getStartColor() == rCandidate.getStartColor()
      93        3253 :                     && getEndColor() == rCandidate.getEndColor()
      94        6506 :                     && getSteps() == rCandidate.getSteps());
      95             :             }
      96             :         };
      97             : 
      98             :         namespace
      99             :         {
     100             :             struct theGlobalDefault :
     101             :                 public rtl::Static< FillGradientAttribute::ImplType, theGlobalDefault > {};
     102             :         }
     103             : 
     104        7346 :         FillGradientAttribute::FillGradientAttribute(
     105             :             GradientStyle eStyle,
     106             :             double fBorder,
     107             :             double fOffsetX,
     108             :             double fOffsetY,
     109             :             double fAngle,
     110             :             const basegfx::BColor& rStartColor,
     111             :             const basegfx::BColor& rEndColor,
     112             :             sal_uInt16 nSteps)
     113             :         :   mpFillGradientAttribute(ImpFillGradientAttribute(
     114        7346 :                 eStyle, fBorder, fOffsetX, fOffsetY, fAngle, rStartColor, rEndColor, nSteps))
     115             :         {
     116        7346 :         }
     117             : 
     118      250593 :         FillGradientAttribute::FillGradientAttribute()
     119      250593 :         :   mpFillGradientAttribute(theGlobalDefault::get())
     120             :         {
     121      250593 :         }
     122             : 
     123      296719 :         FillGradientAttribute::FillGradientAttribute(const FillGradientAttribute& rCandidate)
     124      296719 :         :   mpFillGradientAttribute(rCandidate.mpFillGradientAttribute)
     125             :         {
     126      296719 :         }
     127             : 
     128      553524 :         FillGradientAttribute::~FillGradientAttribute()
     129             :         {
     130      553524 :         }
     131             : 
     132      200540 :         bool FillGradientAttribute::isDefault() const
     133             :         {
     134      200540 :             return mpFillGradientAttribute.same_object(theGlobalDefault::get());
     135             :         }
     136             : 
     137       53583 :         FillGradientAttribute& FillGradientAttribute::operator=(const FillGradientAttribute& rCandidate)
     138             :         {
     139       53583 :             mpFillGradientAttribute = rCandidate.mpFillGradientAttribute;
     140       53583 :             return *this;
     141             :         }
     142             : 
     143       78649 :         bool FillGradientAttribute::operator==(const FillGradientAttribute& rCandidate) const
     144             :         {
     145             :             // tdf#87509 default attr is always != non-default attr, even with same values
     146       78649 :             if(rCandidate.isDefault() != isDefault())
     147           2 :                 return false;
     148             : 
     149       78647 :             return rCandidate.mpFillGradientAttribute == mpFillGradientAttribute;
     150             :         }
     151             : 
     152        2119 :         const basegfx::BColor& FillGradientAttribute::getStartColor() const
     153             :         {
     154        2119 :             return mpFillGradientAttribute->getStartColor();
     155             :         }
     156             : 
     157        2119 :         const basegfx::BColor& FillGradientAttribute::getEndColor() const
     158             :         {
     159        2119 :             return mpFillGradientAttribute->getEndColor();
     160             :         }
     161             : 
     162        1814 :         double FillGradientAttribute::getBorder() const
     163             :         {
     164        1814 :             return mpFillGradientAttribute->getBorder();
     165             :         }
     166             : 
     167           9 :         double FillGradientAttribute::getOffsetX() const
     168             :         {
     169           9 :             return mpFillGradientAttribute->getOffsetX();
     170             :         }
     171             : 
     172           9 :         double FillGradientAttribute::getOffsetY() const
     173             :         {
     174           9 :             return mpFillGradientAttribute->getOffsetY();
     175             :         }
     176             : 
     177        1814 :         double FillGradientAttribute::getAngle() const
     178             :         {
     179        1814 :             return mpFillGradientAttribute->getAngle();
     180             :         }
     181             : 
     182        3579 :         GradientStyle FillGradientAttribute::getStyle() const
     183             :         {
     184        3579 :             return mpFillGradientAttribute->getStyle();
     185             :         }
     186             : 
     187        1814 :         sal_uInt16 FillGradientAttribute::getSteps() const
     188             :         {
     189        1814 :             return mpFillGradientAttribute->getSteps();
     190             :         }
     191             : 
     192             :     } // end of namespace attribute
     193             : } // end of namespace drawinglayer
     194             : 
     195             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11