LCOV - code coverage report
Current view: top level - libreoffice/basegfx/source/tools - gradienttools.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 33 121 27.3 %
Date: 2012-12-27 Functions: 2 9 22.2 %
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 <basegfx/tools/gradienttools.hxx>
      21             : #include <basegfx/point/b2dpoint.hxx>
      22             : #include <basegfx/range/b2drange.hxx>
      23             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      24             : 
      25             : namespace basegfx
      26             : {
      27             :     /** Most of the setup for linear & axial gradient is the same, except
      28             :         for the border treatment. Factored out here.
      29             :     */
      30           3 :     static void init1DGradientInfo(ODFGradientInfo& o_rGradientInfo,
      31             :                                    const B2DRange&  rTargetRange,
      32             :                                    sal_uInt32       nSteps,
      33             :                                    double           fBorder,
      34             :                                    double           fAngle,
      35             :                                    bool             bAxial)
      36             :     {
      37           3 :         o_rGradientInfo.maTextureTransform.identity();
      38           3 :         o_rGradientInfo.maBackTextureTransform.identity();
      39           3 :         o_rGradientInfo.mnSteps = nSteps;
      40             : 
      41           3 :         fAngle = -fAngle;
      42             : 
      43           3 :         double fTargetSizeX(rTargetRange.getWidth());
      44           3 :         double fTargetSizeY(rTargetRange.getHeight());
      45           3 :         double fTargetOffsetX(rTargetRange.getMinX());
      46           3 :         double fTargetOffsetY(rTargetRange.getMinY());
      47             : 
      48             :         // add object expansion
      49           3 :         if(0.0 != fAngle)
      50             :         {
      51           3 :             const double fAbsCos(fabs(cos(fAngle)));
      52           3 :             const double fAbsSin(fabs(sin(fAngle)));
      53           3 :             const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin);
      54           3 :             const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin);
      55           3 :             fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0;
      56           3 :             fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0;
      57           3 :             fTargetSizeX = fNewX;
      58           3 :             fTargetSizeY = fNewY;
      59             :         }
      60             : 
      61           3 :         const double fSizeWithoutBorder=1.0 - fBorder;
      62           3 :         if( bAxial )
      63             :         {
      64           0 :             o_rGradientInfo.maTextureTransform.scale(1.0, fSizeWithoutBorder * .5);
      65           0 :             o_rGradientInfo.maTextureTransform.translate(0.0, 0.5);
      66             :         }
      67             :         else
      68             :         {
      69           3 :             if(!fTools::equal(fSizeWithoutBorder, 1.0))
      70             :             {
      71           0 :                 o_rGradientInfo.maTextureTransform.scale(1.0, fSizeWithoutBorder);
      72           0 :                 o_rGradientInfo.maTextureTransform.translate(0.0, fBorder);
      73             :             }
      74             :         }
      75             : 
      76           3 :         o_rGradientInfo.maTextureTransform.scale(fTargetSizeX, fTargetSizeY);
      77             : 
      78             :         // add texture rotate after scale to keep perpendicular angles
      79           3 :         if(0.0 != fAngle)
      80             :         {
      81             :             const B2DPoint aCenter(0.5*fTargetSizeX,
      82           3 :                                    0.5*fTargetSizeY);
      83             :             o_rGradientInfo.maTextureTransform *=
      84           3 :                 basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
      85             :         }
      86             : 
      87             :         // add object translate
      88           3 :         o_rGradientInfo.maTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
      89             : 
      90             :         // prepare aspect for texture
      91           3 :         o_rGradientInfo.mfAspectRatio = (0.0 != fTargetSizeY) ?  fTargetSizeX / fTargetSizeY : 1.0;
      92             : 
      93             :         // build transform from u,v to [0.0 .. 1.0].
      94           3 :         o_rGradientInfo.maBackTextureTransform = o_rGradientInfo.maTextureTransform;
      95           3 :         o_rGradientInfo.maBackTextureTransform.invert();
      96           3 :     }
      97             : 
      98             :     /** Most of the setup for radial & ellipsoidal gradient is the same,
      99             :         except for the border treatment. Factored out here.
     100             :     */
     101           0 :     static void initEllipticalGradientInfo(ODFGradientInfo& o_rGradientInfo,
     102             :                                            const B2DRange&  rTargetRange,
     103             :                                            const B2DVector& rOffset,
     104             :                                            sal_uInt32       nSteps,
     105             :                                            double           fBorder,
     106             :                                            double           fAngle,
     107             :                                            bool             bCircular)
     108             :     {
     109           0 :         o_rGradientInfo.maTextureTransform.identity();
     110           0 :         o_rGradientInfo.maBackTextureTransform.identity();
     111           0 :         o_rGradientInfo.mnSteps = nSteps;
     112             : 
     113           0 :         fAngle = -fAngle;
     114             : 
     115           0 :         double fTargetSizeX(rTargetRange.getWidth());
     116           0 :         double fTargetSizeY(rTargetRange.getHeight());
     117           0 :         double fTargetOffsetX(rTargetRange.getMinX());
     118           0 :         double fTargetOffsetY(rTargetRange.getMinY());
     119             : 
     120             :         // add object expansion
     121           0 :         if( bCircular )
     122             :         {
     123           0 :             const double fOriginalDiag(sqrt((fTargetSizeX * fTargetSizeX) + (fTargetSizeY * fTargetSizeY)));
     124           0 :             fTargetOffsetX -= (fOriginalDiag - fTargetSizeX) / 2.0;
     125           0 :             fTargetOffsetY -= (fOriginalDiag - fTargetSizeY) / 2.0;
     126           0 :             fTargetSizeX = fOriginalDiag;
     127           0 :             fTargetSizeY = fOriginalDiag;
     128             :         }
     129             :         else
     130             :         {
     131           0 :             fTargetOffsetX -= (0.4142 / 2.0 ) * fTargetSizeX;
     132           0 :             fTargetOffsetY -= (0.4142 / 2.0 ) * fTargetSizeY;
     133           0 :             fTargetSizeX = 1.4142 * fTargetSizeX;
     134           0 :             fTargetSizeY = 1.4142 * fTargetSizeY;
     135             :         }
     136             : 
     137           0 :         const double fHalfBorder((1.0 - fBorder) * 0.5);
     138           0 :         o_rGradientInfo.maTextureTransform.scale(fHalfBorder, fHalfBorder);
     139             : 
     140           0 :         o_rGradientInfo.maTextureTransform.translate(0.5, 0.5);
     141           0 :         o_rGradientInfo.maTextureTransform.scale(fTargetSizeX, fTargetSizeY);
     142             : 
     143             :         // add texture rotate after scale to keep perpendicular angles
     144           0 :         if( !bCircular && 0.0 != fAngle)
     145             :         {
     146             :             const B2DPoint aCenter(0.5*fTargetSizeX,
     147           0 :                                    0.5*fTargetSizeY);
     148             :             o_rGradientInfo.maTextureTransform *=
     149           0 :                 basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
     150             :         }
     151             : 
     152             :         // add defined offsets after rotation
     153           0 :         if(0.5 != rOffset.getX() || 0.5 != rOffset.getY())
     154             :         {
     155             :             // use original target size
     156           0 :             fTargetOffsetX += (rOffset.getX() - 0.5) * rTargetRange.getWidth();
     157           0 :             fTargetOffsetY += (rOffset.getY() - 0.5) * rTargetRange.getHeight();
     158             :         }
     159             : 
     160             :         // add object translate
     161           0 :         o_rGradientInfo.maTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
     162             : 
     163             :         // prepare aspect for texture
     164           0 :         o_rGradientInfo.mfAspectRatio = (0.0 != fTargetSizeY) ?  fTargetSizeX / fTargetSizeY : 1.0;
     165             : 
     166             :         // build transform from u,v to [0.0 .. 1.0].
     167           0 :         o_rGradientInfo.maBackTextureTransform = o_rGradientInfo.maTextureTransform;
     168           0 :         o_rGradientInfo.maBackTextureTransform.invert();
     169           0 :     }
     170             : 
     171             :     /** Setup for rect & square gradient is exactly the same. Factored out
     172             :         here.
     173             :     */
     174           0 :     static void initRectGradientInfo(ODFGradientInfo& o_rGradientInfo,
     175             :                                      const B2DRange&  rTargetRange,
     176             :                                      const B2DVector& rOffset,
     177             :                                      sal_uInt32       nSteps,
     178             :                                      double           fBorder,
     179             :                                      double           fAngle,
     180             :                                      bool             bSquare)
     181             :     {
     182           0 :         o_rGradientInfo.maTextureTransform.identity();
     183           0 :         o_rGradientInfo.maBackTextureTransform.identity();
     184           0 :         o_rGradientInfo.mnSteps = nSteps;
     185             : 
     186           0 :         fAngle = -fAngle;
     187             : 
     188           0 :         double fTargetSizeX(rTargetRange.getWidth());
     189           0 :         double fTargetSizeY(rTargetRange.getHeight());
     190           0 :         double fTargetOffsetX(rTargetRange.getMinX());
     191           0 :         double fTargetOffsetY(rTargetRange.getMinY());
     192             : 
     193             :         // add object expansion
     194           0 :         if(0.0 != fAngle)
     195             :         {
     196           0 :             const double fAbsCos(fabs(cos(fAngle)));
     197           0 :             const double fAbsSin(fabs(sin(fAngle)));
     198           0 :             const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin);
     199           0 :             const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin);
     200           0 :             fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0;
     201           0 :             fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0;
     202           0 :             fTargetSizeX = fNewX;
     203           0 :             fTargetSizeY = fNewY;
     204             :         }
     205             : 
     206           0 :         const double fHalfBorder((1.0 - fBorder) * 0.5);
     207           0 :         o_rGradientInfo.maTextureTransform.scale(fHalfBorder, fHalfBorder);
     208             : 
     209           0 :         o_rGradientInfo.maTextureTransform.translate(0.5, 0.5);
     210           0 :         o_rGradientInfo.maTextureTransform.scale(fTargetSizeX, fTargetSizeY);
     211             : 
     212             :         // add texture rotate after scale to keep perpendicular angles
     213           0 :         if(0.0 != fAngle)
     214             :         {
     215             :             const B2DPoint aCenter(0.5*fTargetSizeX,
     216           0 :                                    0.5*fTargetSizeY);
     217             :             o_rGradientInfo.maTextureTransform *=
     218           0 :                 basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
     219             :         }
     220             : 
     221             :         // add defined offsets after rotation
     222           0 :         if(0.5 != rOffset.getX() || 0.5 != rOffset.getY())
     223             :         {
     224             :             // use scaled target size
     225           0 :             fTargetOffsetX += (rOffset.getX() - 0.5) * fTargetSizeX;
     226           0 :             fTargetOffsetY += (rOffset.getY() - 0.5) * fTargetSizeY;
     227             :         }
     228             : 
     229             :         // add object translate
     230           0 :         o_rGradientInfo.maTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
     231             : 
     232             :         // prepare aspect for texture
     233           0 :         if( bSquare )
     234           0 :             o_rGradientInfo.mfAspectRatio = 1.0; // since we want a square
     235             :         else
     236           0 :             o_rGradientInfo.mfAspectRatio = (0.0 != fTargetSizeY) ?  fTargetSizeX / fTargetSizeY : 1.0;
     237             : 
     238             :         // build transform from u,v to [0.0 .. 1.0]. As base, use inverse texture transform
     239           0 :         o_rGradientInfo.maBackTextureTransform = o_rGradientInfo.maTextureTransform;
     240           0 :         o_rGradientInfo.maBackTextureTransform.invert();
     241           0 :     }
     242             : 
     243             :     namespace tools
     244             :     {
     245           3 :         ODFGradientInfo& createLinearODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
     246             :                                                      const B2DRange&  rTargetArea,
     247             :                                                      sal_uInt32       nSteps,
     248             :                                                      double           fBorder,
     249             :                                                      double           fAngle)
     250             :         {
     251             :             init1DGradientInfo(o_rGradientInfo,
     252             :                                rTargetArea,
     253             :                                nSteps,
     254             :                                fBorder,
     255             :                                fAngle,
     256           3 :                                false);
     257           3 :             return o_rGradientInfo;
     258             :         }
     259             : 
     260           0 :         ODFGradientInfo& createAxialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
     261             :                                                     const B2DRange&  rTargetArea,
     262             :                                                     sal_uInt32       nSteps,
     263             :                                                     double           fBorder,
     264             :                                                     double           fAngle)
     265             :         {
     266             :             init1DGradientInfo(o_rGradientInfo,
     267             :                                rTargetArea,
     268             :                                nSteps,
     269             :                                fBorder,
     270             :                                fAngle,
     271           0 :                                true);
     272           0 :             return o_rGradientInfo;
     273             :         }
     274             : 
     275           0 :         ODFGradientInfo& createRadialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
     276             :                                                      const B2DRange&  rTargetArea,
     277             :                                                      const B2DVector& rOffset,
     278             :                                                      sal_uInt32       nSteps,
     279             :                                                      double           fBorder)
     280             :         {
     281             :             initEllipticalGradientInfo(o_rGradientInfo,
     282             :                                        rTargetArea,
     283             :                                        rOffset,
     284             :                                        nSteps,
     285             :                                        fBorder,
     286             :                                        0.0,
     287           0 :                                        true);
     288           0 :             return o_rGradientInfo;
     289             :         }
     290             : 
     291           0 :         ODFGradientInfo& createEllipticalODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
     292             :                                                          const B2DRange&  rTargetArea,
     293             :                                                          const B2DVector& rOffset,
     294             :                                                          sal_uInt32       nSteps,
     295             :                                                          double           fBorder,
     296             :                                                          double           fAngle)
     297             :         {
     298             :             initEllipticalGradientInfo(o_rGradientInfo,
     299             :                                        rTargetArea,
     300             :                                        rOffset,
     301             :                                        nSteps,
     302             :                                        fBorder,
     303             :                                        fAngle,
     304           0 :                                        false);
     305           0 :             return o_rGradientInfo;
     306             :         }
     307             : 
     308           0 :         ODFGradientInfo& createSquareODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
     309             :                                                      const B2DRange&  rTargetArea,
     310             :                                                      const B2DVector& rOffset,
     311             :                                                      sal_uInt32       nSteps,
     312             :                                                      double           fBorder,
     313             :                                                      double           fAngle)
     314             :         {
     315             :             initRectGradientInfo(o_rGradientInfo,
     316             :                                  rTargetArea,
     317             :                                  rOffset,
     318             :                                  nSteps,
     319             :                                  fBorder,
     320             :                                  fAngle,
     321           0 :                                  true);
     322           0 :             return o_rGradientInfo;
     323             :         }
     324             : 
     325           0 :         ODFGradientInfo& createRectangularODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
     326             :                                                           const B2DRange&  rTargetArea,
     327             :                                                           const B2DVector& rOffset,
     328             :                                                           sal_uInt32       nSteps,
     329             :                                                           double           fBorder,
     330             :                                                           double           fAngle)
     331             :         {
     332             :             initRectGradientInfo(o_rGradientInfo,
     333             :                                  rTargetArea,
     334             :                                  rOffset,
     335             :                                  nSteps,
     336             :                                  fBorder,
     337             :                                  fAngle,
     338           0 :                                  false);
     339           0 :             return o_rGradientInfo;
     340             :         }
     341             : 
     342             :     } // namespace tools
     343             : 
     344             : } // namespace basegfx
     345             : 
     346             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10