LCOV - code coverage report
Current view: top level - vcl/source/gdi - gradient.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 185 0.0 %
Date: 2014-04-14 Functions: 0 24 0.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 <tools/stream.hxx>
      21             : #include <tools/vcompat.hxx>
      22             : #include <tools/debug.hxx>
      23             : #include <tools/gen.hxx>
      24             : #include <vcl/gradient.hxx>
      25             : 
      26           0 : Impl_Gradient::Impl_Gradient() :
      27             :     maStartColor( COL_BLACK ),
      28           0 :     maEndColor( COL_WHITE )
      29             : {
      30           0 :     mnRefCount          = 1;
      31           0 :     meStyle             = GradientStyle_LINEAR;
      32           0 :     mnAngle             = 0;
      33           0 :     mnBorder            = 0;
      34           0 :     mnOfsX              = 50;
      35           0 :     mnOfsY              = 50;
      36           0 :     mnIntensityStart    = 100;
      37           0 :     mnIntensityEnd      = 100;
      38           0 :     mnStepCount         = 0;
      39           0 : }
      40             : 
      41           0 : Impl_Gradient::Impl_Gradient( const Impl_Gradient& rImplGradient ) :
      42             :     maStartColor( rImplGradient.maStartColor ),
      43           0 :     maEndColor( rImplGradient.maEndColor )
      44             : {
      45           0 :     mnRefCount          = 1;
      46           0 :     meStyle             = rImplGradient.meStyle;
      47           0 :     mnAngle             = rImplGradient.mnAngle;
      48           0 :     mnBorder            = rImplGradient.mnBorder;
      49           0 :     mnOfsX              = rImplGradient.mnOfsX;
      50           0 :     mnOfsY              = rImplGradient.mnOfsY;
      51           0 :     mnIntensityStart    = rImplGradient.mnIntensityStart;
      52           0 :     mnIntensityEnd      = rImplGradient.mnIntensityEnd;
      53           0 :     mnStepCount         = rImplGradient.mnStepCount;
      54           0 : }
      55             : 
      56           0 : void Gradient::MakeUnique()
      57             : {
      58             :     // If there are still other references, copy
      59           0 :     if ( mpImplGradient->mnRefCount != 1 )
      60             :     {
      61           0 :         if( mpImplGradient->mnRefCount )
      62           0 :             mpImplGradient->mnRefCount--;
      63             : 
      64           0 :         mpImplGradient = new Impl_Gradient( *mpImplGradient );
      65             :     }
      66           0 : }
      67             : 
      68           0 : Gradient::Gradient()
      69             : {
      70             : 
      71           0 :     mpImplGradient = new Impl_Gradient;
      72           0 : }
      73             : 
      74           0 : Gradient::Gradient( const Gradient& rGradient )
      75             : {
      76             : 
      77             :     // Take over instance data and increment refcount
      78           0 :     mpImplGradient = rGradient.mpImplGradient;
      79           0 :     mpImplGradient->mnRefCount++;
      80           0 : }
      81             : 
      82           0 : Gradient::Gradient( GradientStyle eStyle,
      83             :                     const Color& rStartColor, const Color& rEndColor )
      84             : {
      85             : 
      86           0 :     mpImplGradient                  = new Impl_Gradient;
      87           0 :     mpImplGradient->meStyle         = eStyle;
      88           0 :     mpImplGradient->maStartColor    = rStartColor;
      89           0 :     mpImplGradient->maEndColor      = rEndColor;
      90           0 : }
      91             : 
      92           0 : Gradient::~Gradient()
      93             : {
      94             : 
      95             :     // If it's the last reference, delete it, otherwise
      96             :     // decrement refcount
      97           0 :     if ( mpImplGradient->mnRefCount == 1 )
      98           0 :         delete mpImplGradient;
      99             :     else
     100           0 :         mpImplGradient->mnRefCount--;
     101           0 : }
     102             : 
     103           0 : void Gradient::SetStyle( GradientStyle eStyle )
     104             : {
     105             : 
     106           0 :     MakeUnique();
     107           0 :     mpImplGradient->meStyle = eStyle;
     108           0 : }
     109             : 
     110           0 : void Gradient::SetStartColor( const Color& rColor )
     111             : {
     112             : 
     113           0 :     MakeUnique();
     114           0 :     mpImplGradient->maStartColor = rColor;
     115           0 : }
     116             : 
     117           0 : void Gradient::SetEndColor( const Color& rColor )
     118             : {
     119             : 
     120           0 :     MakeUnique();
     121           0 :     mpImplGradient->maEndColor = rColor;
     122           0 : }
     123             : 
     124           0 : void Gradient::SetAngle( sal_uInt16 nAngle )
     125             : {
     126             : 
     127           0 :     MakeUnique();
     128           0 :     mpImplGradient->mnAngle = nAngle;
     129           0 : }
     130             : 
     131           0 : void Gradient::SetBorder( sal_uInt16 nBorder )
     132             : {
     133             : 
     134           0 :     MakeUnique();
     135           0 :     mpImplGradient->mnBorder = nBorder;
     136           0 : }
     137             : 
     138           0 : void Gradient::SetOfsX( sal_uInt16 nOfsX )
     139             : {
     140             : 
     141           0 :     MakeUnique();
     142           0 :     mpImplGradient->mnOfsX = nOfsX;
     143           0 : }
     144             : 
     145           0 : void Gradient::SetOfsY( sal_uInt16 nOfsY )
     146             : {
     147             : 
     148           0 :     MakeUnique();
     149           0 :     mpImplGradient->mnOfsY = nOfsY;
     150           0 : }
     151             : 
     152           0 : void Gradient::SetStartIntensity( sal_uInt16 nIntens )
     153             : {
     154             : 
     155           0 :     MakeUnique();
     156           0 :     mpImplGradient->mnIntensityStart = nIntens;
     157           0 : }
     158             : 
     159           0 : void Gradient::SetEndIntensity( sal_uInt16 nIntens )
     160             : {
     161             : 
     162           0 :     MakeUnique();
     163           0 :     mpImplGradient->mnIntensityEnd = nIntens;
     164           0 : }
     165             : 
     166           0 : void Gradient::SetSteps( sal_uInt16 nSteps )
     167             : {
     168             : 
     169           0 :     MakeUnique();
     170           0 :     mpImplGradient->mnStepCount = nSteps;
     171           0 : }
     172             : 
     173           0 : void Gradient::GetBoundRect( const Rectangle& rRect, Rectangle& rBoundRect, Point& rCenter ) const
     174             : {
     175           0 :     Rectangle aRect( rRect );
     176           0 :     sal_uInt16 nAngle = GetAngle() % 3600;
     177             : 
     178           0 :     if( GetStyle() == GradientStyle_LINEAR || GetStyle() == GradientStyle_AXIAL )
     179             :     {
     180           0 :         const double    fAngle = nAngle * F_PI1800;
     181           0 :         const double    fWidth = aRect.GetWidth();
     182           0 :         const double    fHeight = aRect.GetHeight();
     183           0 :         double  fDX     = fWidth  * fabs( cos( fAngle ) ) +
     184           0 :                           fHeight * fabs( sin( fAngle ) );
     185           0 :         double  fDY     = fHeight * fabs( cos( fAngle ) ) +
     186           0 :                           fWidth  * fabs( sin( fAngle ) );
     187           0 :                 fDX     = (fDX - fWidth)  * 0.5 + 0.5;
     188           0 :                 fDY     = (fDY - fHeight) * 0.5 + 0.5;
     189           0 :         aRect.Left()   -= (long) fDX;
     190           0 :         aRect.Right()  += (long) fDX;
     191           0 :         aRect.Top()    -= (long) fDY;
     192           0 :         aRect.Bottom() += (long) fDY;
     193             : 
     194           0 :         rBoundRect = aRect;
     195           0 :         rCenter = rRect.Center();
     196             :     }
     197             :     else
     198             :     {
     199           0 :         if( GetStyle() == GradientStyle_SQUARE || GetStyle() == GradientStyle_RECT )
     200             :         {
     201           0 :             const double    fAngle = nAngle * F_PI1800;
     202           0 :             const double    fWidth = aRect.GetWidth();
     203           0 :             const double    fHeight = aRect.GetHeight();
     204           0 :             double          fDX = fWidth  * fabs( cos( fAngle ) ) + fHeight * fabs( sin( fAngle ) );
     205           0 :             double          fDY = fHeight * fabs( cos( fAngle ) ) + fWidth  * fabs( sin( fAngle ) );
     206             : 
     207           0 :             fDX = ( fDX - fWidth  ) * 0.5 + 0.5;
     208           0 :             fDY = ( fDY - fHeight ) * 0.5 + 0.5;
     209             : 
     210           0 :             aRect.Left()   -= (long) fDX;
     211           0 :             aRect.Right()  += (long) fDX;
     212           0 :             aRect.Top()    -= (long) fDY;
     213           0 :             aRect.Bottom() += (long) fDY;
     214             :         }
     215             : 
     216           0 :         Size aSize( aRect.GetSize() );
     217             : 
     218           0 :         if( GetStyle() == GradientStyle_RADIAL )
     219             :         {
     220             :             // Calculation of radii for circle
     221           0 :             aSize.Width() = (long)(0.5 + sqrt((double)aSize.Width()*(double)aSize.Width() + (double)aSize.Height()*(double)aSize.Height()));
     222           0 :             aSize.Height() = aSize.Width();
     223             :         }
     224           0 :         else if( GetStyle() == GradientStyle_ELLIPTICAL )
     225             :         {
     226             :             // Calculation of radii for ellipse
     227           0 :             aSize.Width() = (long)( 0.5 + (double) aSize.Width()  * 1.4142 );
     228           0 :             aSize.Height() = (long)( 0.5 + (double) aSize.Height() * 1.4142 );
     229             :         }
     230             : 
     231             :         // Calculate new centers
     232           0 :         long    nZWidth = aRect.GetWidth() * (long) GetOfsX() / 100;
     233           0 :         long    nZHeight = aRect.GetHeight() * (long) GetOfsY() / 100;
     234           0 :         long    nBorderX = (long) GetBorder() * aSize.Width()  / 100;
     235           0 :         long    nBorderY = (long) GetBorder() * aSize.Height() / 100;
     236           0 :         rCenter = Point( aRect.Left() + nZWidth, aRect.Top() + nZHeight );
     237             : 
     238             :         // Respect borders
     239           0 :         aSize.Width() -= nBorderX;
     240           0 :         aSize.Height() -= nBorderY;
     241             : 
     242             :         // Recalculate output rectangle
     243           0 :         aRect.Left() = rCenter.X() - ( aSize.Width() >> 1 );
     244           0 :         aRect.Top() = rCenter.Y() - ( aSize.Height() >> 1 );
     245             : 
     246           0 :         aRect.SetSize( aSize );
     247           0 :         rBoundRect = aRect;
     248             :     }
     249           0 : }
     250             : 
     251           0 : Gradient& Gradient::operator=( const Gradient& rGradient )
     252             : {
     253             : 
     254             :     // Increment refcount first so that we can reference ourselves
     255           0 :     rGradient.mpImplGradient->mnRefCount++;
     256             : 
     257             :     // If it's the last reference, delete it, otherwise decrement
     258           0 :     if ( mpImplGradient->mnRefCount == 1 )
     259           0 :         delete mpImplGradient;
     260             :     else
     261           0 :         mpImplGradient->mnRefCount--;
     262           0 :     mpImplGradient = rGradient.mpImplGradient;
     263             : 
     264           0 :     return *this;
     265             : }
     266             : 
     267           0 : bool Gradient::operator==( const Gradient& rGradient ) const
     268             : {
     269             : 
     270           0 :     if ( mpImplGradient == rGradient.mpImplGradient )
     271           0 :         return true;
     272             : 
     273           0 :     if ( (mpImplGradient->meStyle           == rGradient.mpImplGradient->meStyle)           &&
     274           0 :          (mpImplGradient->mnAngle           == rGradient.mpImplGradient->mnAngle)           &&
     275           0 :          (mpImplGradient->mnBorder          == rGradient.mpImplGradient->mnBorder)          &&
     276           0 :          (mpImplGradient->mnOfsX            == rGradient.mpImplGradient->mnOfsX)            &&
     277           0 :          (mpImplGradient->mnOfsY            == rGradient.mpImplGradient->mnOfsY)            &&
     278           0 :          (mpImplGradient->mnStepCount       == rGradient.mpImplGradient->mnStepCount)       &&
     279           0 :          (mpImplGradient->mnIntensityStart  == rGradient.mpImplGradient->mnIntensityStart)  &&
     280           0 :          (mpImplGradient->mnIntensityEnd    == rGradient.mpImplGradient->mnIntensityEnd)    &&
     281           0 :          (mpImplGradient->maStartColor      == rGradient.mpImplGradient->maStartColor)      &&
     282           0 :          (mpImplGradient->maEndColor        == rGradient.mpImplGradient->maEndColor) )
     283           0 :          return true;
     284             :     else
     285           0 :         return false;
     286             : }
     287             : 
     288           0 : SvStream& ReadImpl_Gradient( SvStream& rIStm, Impl_Gradient& rImpl_Gradient )
     289             : {
     290           0 :     VersionCompat   aCompat( rIStm, STREAM_READ );
     291             :     sal_uInt16          nTmp16;
     292             : 
     293           0 :     rIStm.ReadUInt16( nTmp16 ); rImpl_Gradient.meStyle = (GradientStyle) nTmp16;
     294             : 
     295           0 :     ReadColor( rIStm, rImpl_Gradient.maStartColor );
     296           0 :     ReadColor( rIStm, rImpl_Gradient.maEndColor );
     297           0 :     rIStm.ReadUInt16( rImpl_Gradient.mnAngle ).             ReadUInt16( rImpl_Gradient.mnBorder ).             ReadUInt16( rImpl_Gradient.mnOfsX ).             ReadUInt16( rImpl_Gradient.mnOfsY ).             ReadUInt16( rImpl_Gradient.mnIntensityStart ).             ReadUInt16( rImpl_Gradient.mnIntensityEnd ).             ReadUInt16( rImpl_Gradient.mnStepCount );
     298             : 
     299           0 :     return rIStm;
     300             : }
     301             : 
     302           0 : SvStream& WriteImpl_Gradient( SvStream& rOStm, const Impl_Gradient& rImpl_Gradient )
     303             : {
     304           0 :     VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
     305             : 
     306           0 :     rOStm.WriteUInt16( (sal_uInt16) rImpl_Gradient.meStyle );
     307           0 :     WriteColor( rOStm, rImpl_Gradient.maStartColor );
     308           0 :     WriteColor( rOStm, rImpl_Gradient.maEndColor );
     309           0 :     rOStm.WriteUInt16( rImpl_Gradient.mnAngle )
     310           0 :          .WriteUInt16( rImpl_Gradient.mnBorder )
     311           0 :          .WriteUInt16( rImpl_Gradient.mnOfsX )
     312           0 :          .WriteUInt16( rImpl_Gradient.mnOfsY )
     313           0 :          .WriteUInt16( rImpl_Gradient.mnIntensityStart )
     314           0 :          .WriteUInt16( rImpl_Gradient.mnIntensityEnd )
     315           0 :          .WriteUInt16( rImpl_Gradient.mnStepCount );
     316             : 
     317           0 :     return rOStm;
     318             : }
     319             : 
     320           0 : SvStream& ReadGradient( SvStream& rIStm, Gradient& rGradient )
     321             : {
     322           0 :     rGradient.MakeUnique();
     323           0 :     return ReadImpl_Gradient( rIStm, *rGradient.mpImplGradient );
     324             : }
     325             : 
     326           0 : SvStream& WriteGradient( SvStream& rOStm, const Gradient& rGradient )
     327             : {
     328           0 :     return WriteImpl_Gradient( rOStm, *rGradient.mpImplGradient );
     329             : }
     330             : 
     331             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10