LCOV - code coverage report
Current view: top level - vcl/source/gdi - graphictools.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 126 136 92.6 %
Date: 2015-06-13 12:38:46 Functions: 18 21 85.7 %
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 <tools/vcompat.hxx>
      21             : 
      22             : #include <vcl/graphictools.hxx>
      23             : 
      24          92 : SvtGraphicFill::Transform::Transform()
      25             : {
      26          92 :     matrix[0] = 1.0; matrix[1] = 0.0; matrix[2] = 0.0;
      27          92 :     matrix[3] = 0.0; matrix[4] = 1.0; matrix[5] = 0.0;
      28          92 : }
      29             : 
      30        1414 : SvtGraphicStroke::SvtGraphicStroke() :
      31             :     maPath(),
      32             :     maStartArrow(),
      33             :     maEndArrow(),
      34             :     mfTransparency(),
      35             :     mfStrokeWidth(),
      36             :     maCapType(),
      37             :     maJoinType(),
      38             :     mfMiterLimit( 3.0 ),
      39        1414 :     maDashArray()
      40             : {
      41        1414 : }
      42             : 
      43        1981 : SvtGraphicStroke::SvtGraphicStroke( const Polygon&      rPath,
      44             :                                     const tools::PolyPolygon&  rStartArrow,
      45             :                                     const tools::PolyPolygon&  rEndArrow,
      46             :                                     double              fTransparency,
      47             :                                     double              fStrokeWidth,
      48             :                                     CapType             aCap,
      49             :                                     JoinType            aJoin,
      50             :                                     double              fMiterLimit,
      51             :                                     const DashArray&    rDashArray  ) :
      52             :     maPath( rPath ),
      53             :     maStartArrow( rStartArrow ),
      54             :     maEndArrow( rEndArrow ),
      55             :     mfTransparency( fTransparency ),
      56             :     mfStrokeWidth( fStrokeWidth ),
      57             :     maCapType( aCap ),
      58             :     maJoinType( aJoin ),
      59             :     mfMiterLimit( fMiterLimit ),
      60        1981 :     maDashArray( rDashArray )
      61             : {
      62        1981 : }
      63             : 
      64        1010 : void SvtGraphicStroke::getPath( Polygon& rPath ) const
      65             : {
      66        1010 :     rPath = maPath;
      67        1010 : }
      68             : 
      69        1010 : void SvtGraphicStroke::getStartArrow( tools::PolyPolygon& rPath ) const
      70             : {
      71        1010 :     rPath = maStartArrow;
      72        1010 : }
      73             : 
      74        1010 : void SvtGraphicStroke::getEndArrow( tools::PolyPolygon& rPath ) const
      75             : {
      76        1010 :     rPath = maEndArrow;
      77        1010 : }
      78             : 
      79             : 
      80             : 
      81             : 
      82             : 
      83             : 
      84           0 : void SvtGraphicStroke::getDashArray( DashArray& rDashArray ) const
      85             : {
      86           0 :     rDashArray = maDashArray;
      87           0 : }
      88             : 
      89        1010 : void SvtGraphicStroke::setPath( const Polygon& rPoly )
      90             : {
      91        1010 :     maPath = rPoly;
      92        1010 : }
      93             : 
      94        1010 : void SvtGraphicStroke::setStartArrow( const tools::PolyPolygon& rPoly )
      95             : {
      96        1010 :     maStartArrow = rPoly;
      97        1010 : }
      98             : 
      99        1010 : void SvtGraphicStroke::setEndArrow( const tools::PolyPolygon& rPoly )
     100             : {
     101        1010 :     maEndArrow = rPoly;
     102        1010 : }
     103             : 
     104         404 : void SvtGraphicStroke::scale( double fXScale, double fYScale )
     105             : {
     106             :     // Clearly scaling stroke-width for fat lines is rather a problem
     107         404 :     maPath.Scale( fXScale, fYScale );
     108             : 
     109         404 :     double fScale = sqrt (fabs (fXScale * fYScale) ); // clearly not ideal.
     110         404 :     mfStrokeWidth *= fScale;
     111         404 :     mfMiterLimit *= fScale;
     112             : 
     113         404 :     maStartArrow.Scale( fXScale, fYScale );
     114         404 :     maEndArrow.Scale( fXScale, fYScale );
     115         404 : }
     116             : 
     117        3395 : SvStream& WriteSvtGraphicStroke( SvStream& rOStm, const SvtGraphicStroke& rClass )
     118             : {
     119        3395 :     VersionCompat aCompat( rOStm, StreamMode::WRITE, 1 );
     120             : 
     121        3395 :     rClass.maPath.Write( rOStm );
     122        3395 :     rClass.maStartArrow.Write( rOStm );
     123        3395 :     rClass.maEndArrow.Write( rOStm );
     124        3395 :     rOStm.WriteDouble( rClass.mfTransparency );
     125        3395 :     rOStm.WriteDouble( rClass.mfStrokeWidth );
     126        3395 :     sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maCapType );
     127        3395 :     rOStm.WriteUInt16( nTmp );
     128        3395 :     nTmp = sal::static_int_cast<sal_uInt16>( rClass.maJoinType );
     129        3395 :     rOStm.WriteUInt16( nTmp );
     130        3395 :     rOStm.WriteDouble( rClass.mfMiterLimit );
     131             : 
     132        3395 :     rOStm.WriteUInt32( rClass.maDashArray.size() );
     133             :     size_t i;
     134        3409 :     for(i=0; i<rClass.maDashArray.size(); ++i)
     135          14 :         rOStm.WriteDouble( rClass.maDashArray[i] );
     136             : 
     137        3395 :     return rOStm;
     138             : }
     139             : 
     140        1414 : SvStream& ReadSvtGraphicStroke( SvStream& rIStm, SvtGraphicStroke& rClass )
     141             : {
     142        1414 :     VersionCompat aCompat( rIStm, StreamMode::READ );
     143             : 
     144        1414 :     rClass.maPath.Read( rIStm );
     145        1414 :     rClass.maStartArrow.Read( rIStm );
     146        1414 :     rClass.maEndArrow.Read( rIStm );
     147        1414 :     rIStm.ReadDouble( rClass.mfTransparency );
     148        1414 :     rIStm.ReadDouble( rClass.mfStrokeWidth );
     149             :     sal_uInt16 nTmp;
     150        1414 :     rIStm.ReadUInt16( nTmp );
     151        1414 :     rClass.maCapType = SvtGraphicStroke::CapType(nTmp);
     152        1414 :     rIStm.ReadUInt16( nTmp );
     153        1414 :     rClass.maJoinType = SvtGraphicStroke::JoinType(nTmp);
     154        1414 :     rIStm.ReadDouble( rClass.mfMiterLimit );
     155             : 
     156             :     sal_uInt32 nSize;
     157        1414 :     rIStm.ReadUInt32( nSize );
     158        1414 :     rClass.maDashArray.resize(nSize);
     159             :     size_t i;
     160        1414 :     for(i=0; i<rClass.maDashArray.size(); ++i)
     161           0 :         rIStm.ReadDouble( rClass.maDashArray[i] );
     162             : 
     163        1414 :     return rIStm;
     164             : }
     165             : 
     166          44 : SvtGraphicFill::SvtGraphicFill() :
     167             :     maPath(),
     168             :     maFillColor( COL_BLACK ),
     169             :     mfTransparency(),
     170             :     maFillRule(),
     171             :     maFillType(),
     172             :     maFillTransform(),
     173             :     mbTiling( false ),
     174             :     maHatchType(),
     175             :     maHatchColor( COL_BLACK ),
     176             :     maGradientType(),
     177             :     maGradient1stColor( COL_BLACK ),
     178             :     maGradient2ndColor( COL_BLACK ),
     179             :     maGradientStepCount( gradientStepsInfinite ),
     180          44 :     maFillGraphic()
     181             : {
     182          44 : }
     183             : 
     184          48 : SvtGraphicFill::SvtGraphicFill( const tools::PolyPolygon&  rPath,
     185             :                                 Color               aFillColor,
     186             :                                 double              fTransparency,
     187             :                                 FillRule            aFillRule,
     188             :                                 FillType            aFillType,
     189             :                                 const Transform&    aFillTransform,
     190             :                                 bool                bTiling,
     191             :                                 HatchType           aHatchType,
     192             :                                 Color               aHatchColor,
     193             :                                 GradientType        aGradientType,
     194             :                                 Color               aGradient1stColor,
     195             :                                 Color               aGradient2ndColor,
     196             :                                 sal_Int32           aGradientStepCount,
     197             :                                 const Graphic&      aFillGraphic ) :
     198             :     maPath( rPath ),
     199             :     maFillColor( aFillColor ),
     200             :     mfTransparency( fTransparency ),
     201             :     maFillRule( aFillRule ),
     202             :     maFillType( aFillType ),
     203             :     maFillTransform( aFillTransform ),
     204             :     mbTiling( bTiling ),
     205             :     maHatchType( aHatchType ),
     206             :     maHatchColor( aHatchColor ),
     207             :     maGradientType( aGradientType ),
     208             :     maGradient1stColor( aGradient1stColor ),
     209             :     maGradient2ndColor( aGradient2ndColor ),
     210             :     maGradientStepCount( aGradientStepCount ),
     211          48 :     maFillGraphic( aFillGraphic )
     212             : {
     213          48 : }
     214             : 
     215          44 : void SvtGraphicFill::getPath( tools::PolyPolygon& rPath ) const
     216             : {
     217          44 :     rPath = maPath;
     218          44 : }
     219             : 
     220             : 
     221             : 
     222             : 
     223             : 
     224           0 : void SvtGraphicFill::getTransform( Transform& rTrans ) const
     225             : {
     226           0 :     rTrans = maFillTransform;
     227           0 : }
     228             : 
     229             : 
     230             : 
     231             : 
     232           0 : void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const
     233             : {
     234           0 :     rGraphic = maFillGraphic;
     235           0 : }
     236             : 
     237          44 : void SvtGraphicFill::setPath( const tools::PolyPolygon& rPath )
     238             : {
     239          44 :     maPath = rPath;
     240          44 : }
     241             : 
     242          92 : SvStream& WriteSvtGraphicFill( SvStream& rOStm, const SvtGraphicFill& rClass )
     243             : {
     244          92 :     VersionCompat aCompat( rOStm, StreamMode::WRITE, 1 );
     245             : 
     246          92 :     rClass.maPath.Write( rOStm );
     247          92 :     WriteColor( rOStm, rClass.maFillColor );
     248          92 :     rOStm.WriteDouble( rClass.mfTransparency );
     249          92 :     sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillRule );
     250          92 :     rOStm.WriteUInt16( nTmp );
     251          92 :     nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillType );
     252          92 :     rOStm.WriteUInt16( nTmp );
     253             :     int i;
     254         644 :     for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
     255         552 :         rOStm.WriteDouble( rClass.maFillTransform.matrix[i] );
     256          92 :     nTmp = sal_uInt16(rClass.mbTiling);
     257          92 :     rOStm.WriteUInt16( nTmp );
     258          92 :     nTmp = sal::static_int_cast<sal_uInt16>( rClass.maHatchType );
     259          92 :     rOStm.WriteUInt16( nTmp );
     260          92 :     WriteColor( rOStm, rClass.maHatchColor );
     261          92 :     nTmp = sal::static_int_cast<sal_uInt16>( rClass.maGradientType );
     262          92 :     rOStm.WriteUInt16( nTmp );
     263          92 :     WriteColor( rOStm, rClass.maGradient1stColor );
     264          92 :     WriteColor( rOStm, rClass.maGradient2ndColor );
     265          92 :     rOStm.WriteInt32( rClass.maGradientStepCount );
     266          92 :     WriteGraphic( rOStm, rClass.maFillGraphic );
     267             : 
     268          92 :     return rOStm;
     269             : }
     270             : 
     271          44 : SvStream& ReadSvtGraphicFill( SvStream& rIStm, SvtGraphicFill& rClass )
     272             : {
     273          44 :     VersionCompat aCompat( rIStm, StreamMode::READ );
     274             : 
     275          44 :     rClass.maPath.Read( rIStm );
     276          44 :     ReadColor( rIStm, rClass.maFillColor );
     277          44 :     rIStm.ReadDouble( rClass.mfTransparency );
     278             :     sal_uInt16 nTmp;
     279          44 :     rIStm.ReadUInt16( nTmp );
     280          44 :     rClass.maFillRule = SvtGraphicFill::FillRule( nTmp );
     281          44 :     rIStm.ReadUInt16( nTmp );
     282          44 :     rClass.maFillType = SvtGraphicFill::FillType( nTmp );
     283             :     int i;
     284         308 :     for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
     285         264 :         rIStm.ReadDouble( rClass.maFillTransform.matrix[i] );
     286          44 :     rIStm.ReadUInt16( nTmp );
     287          44 :     rClass.mbTiling = nTmp;
     288          44 :     rIStm.ReadUInt16( nTmp );
     289          44 :     rClass.maHatchType = SvtGraphicFill::HatchType( nTmp );
     290          44 :     ReadColor( rIStm, rClass.maHatchColor );
     291          44 :     rIStm.ReadUInt16( nTmp );
     292          44 :     rClass.maGradientType = SvtGraphicFill::GradientType( nTmp );
     293          44 :     ReadColor( rIStm, rClass.maGradient1stColor );
     294          44 :     ReadColor( rIStm, rClass.maGradient2ndColor );
     295          44 :     rIStm.ReadInt32( rClass.maGradientStepCount );
     296          44 :     ReadGraphic( rIStm, rClass.maFillGraphic );
     297             : 
     298          44 :     return rIStm;
     299             : }
     300             : 
     301             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11