xref: /trunk/main/svx/source/svdraw/gradtrns.cxx (revision 4d196ef4ae78ff6471489db4943d00e5f0bbde43)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"

#include "gradtrns.hxx"
#include <svx/svdobj.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <vcl/salbtype.hxx> // FRound


void GradTransformer::GradToVec(GradTransGradient& rG, GradTransVector& rV, const SdrObject* pObj)
{
    // handle start color
    rV.aCol1 = rG.aGradient.GetStartColor();
    if(100 != rG.aGradient.GetStartIntens())
    {
        const double fFact((double)rG.aGradient.GetStartIntens() / 100.0);
        rV.aCol1 = Color(rV.aCol1.getBColor() * fFact);
    }

    // handle end color
    rV.aCol2 = rG.aGradient.GetEndColor();
    if(100 != rG.aGradient.GetEndIntens())
    {
        const double fFact((double)rG.aGradient.GetEndIntens() / 100.0);
        rV.aCol2 = Color(rV.aCol2.getBColor() * fFact);
    }

    // calc the basic positions
    const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
    const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
    const basegfx::B2DPoint aCenter(aRange.getCenter());
    basegfx::B2DPoint aStartPos, aEndPos;

    switch(rG.aGradient.GetGradientStyle())
    {
        case XGRAD_LINEAR :
        {
            aStartPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMinY());
            aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY());

            if(rG.aGradient.GetBorder())
            {
                basegfx::B2DVector aFullVec(aStartPos - aEndPos);
                const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
                aFullVec.normalize();
                aStartPos = aEndPos + (aFullVec * fLen);
            }

            if(rG.aGradient.GetAngle())
            {
                const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
                const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aCenter, -fAngle));

                aStartPos *= aTransformation;
                aEndPos *= aTransformation;
            }
            break;
        }
        case XGRAD_AXIAL :
        {
            aStartPos = aCenter;
            aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY());

            if(rG.aGradient.GetBorder())
            {
                basegfx::B2DVector aFullVec(aEndPos - aStartPos);
                const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
                aFullVec.normalize();
                aEndPos = aStartPos + (aFullVec * fLen);
            }

            if(rG.aGradient.GetAngle())
            {
                const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
                const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aCenter, -fAngle));

                aStartPos *= aTransformation;
                aEndPos *= aTransformation;
            }
            break;
        }
        case XGRAD_RADIAL :
        case XGRAD_SQUARE :
        {
            aStartPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMaximum().getY());
            aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY());

            if(rG.aGradient.GetBorder())
            {
                basegfx::B2DVector aFullVec(aStartPos - aEndPos);
                const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
                aFullVec.normalize();
                aStartPos = aEndPos + (aFullVec * fLen);
            }

            if(rG.aGradient.GetAngle())
            {
                const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
                const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aEndPos, -fAngle));

                aStartPos *= aTransformation;
                aEndPos *= aTransformation;
            }

            if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset())
            {
                basegfx::B2DPoint aOffset(
                    (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0,
                    (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0);

                aStartPos += aOffset;
                aEndPos += aOffset;
            }

            break;
        }
        case XGRAD_ELLIPTICAL :
        case XGRAD_RECT :
        {
            aStartPos = basegfx::B2DPoint(aRange.getMinX(), aCenter.getY());
            aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY());

            if(rG.aGradient.GetBorder())
            {
                basegfx::B2DVector aFullVec(aStartPos - aEndPos);
                const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
                aFullVec.normalize();
                aStartPos = aEndPos + (aFullVec * fLen);
            }

            if(rG.aGradient.GetAngle())
            {
                const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
                const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aEndPos, -fAngle));

                aStartPos *= aTransformation;
                aEndPos *= aTransformation;
            }

            if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset())
            {
                basegfx::B2DPoint aOffset(
                    (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0,
                    (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0);

                aStartPos += aOffset;
                aEndPos += aOffset;
            }

            break;
        }
    }

    // set values for vector positions now
    rV.maPositionA = aStartPos;
    rV.maPositionB = aEndPos;
}


void GradTransformer::VecToGrad(GradTransVector& rV, GradTransGradient& rG, GradTransGradient& rGOld, const SdrObject* pObj,
    sal_Bool bMoveSingle, sal_Bool bMoveFirst)
{
    // fill old gradient to new gradient to have a base
    rG = rGOld;

    // handle color changes
    if(rV.aCol1 != rGOld.aGradient.GetStartColor())
    {
        rG.aGradient.SetStartColor(rV.aCol1);
        rG.aGradient.SetStartIntens(100);
    }
    if(rV.aCol2 != rGOld.aGradient.GetEndColor())
    {
        rG.aGradient.SetEndColor(rV.aCol2);
        rG.aGradient.SetEndIntens(100);
    }

    // calc the basic positions
    const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
    const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
    const basegfx::B2DPoint aCenter(aRange.getCenter());
    basegfx::B2DPoint aStartPos(rV.maPositionA);
    basegfx::B2DPoint aEndPos(rV.maPositionB);

    switch(rG.aGradient.GetGradientStyle())
    {
        case XGRAD_LINEAR :
        {
            if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
            {
                basegfx::B2DVector aFullVec(aEndPos - aStartPos);

                if(bMoveSingle)
                {
                    aFullVec = aEndPos - aCenter;
                }

                aFullVec.normalize();

                double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
                fNewFullAngle /= F_PI180;
                fNewFullAngle *= -10.0;
                fNewFullAngle += 900.0;

                // clip
                while(fNewFullAngle < 0.0)
                {
                    fNewFullAngle += 3600.0;
                }

                while(fNewFullAngle >= 3600.0)
                {
                    fNewFullAngle -= 3600.0;
                }

                // to int and set
                sal_Int32 nNewAngle = FRound(fNewFullAngle);

                if(nNewAngle != rGOld.aGradient.GetAngle())
                {
                    rG.aGradient.SetAngle(nNewAngle);
                }
            }

            if(!bMoveSingle || (bMoveSingle && bMoveFirst))
            {
                const basegfx::B2DVector aFullVec(aEndPos - aStartPos);
                const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
                const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
                const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
                const double fFullLen(aFullVec.getLength());
                const double fOldLen(aOldVec.getLength());
                const double fNewBorder((fFullLen * 100.0) / fOldLen);
                sal_Int32 nNewBorder(100L - FRound(fNewBorder));

                // clip
                if(nNewBorder < 0L)
                {
                    nNewBorder = 0L;
                }

                if(nNewBorder > 100L)
                {
                    nNewBorder = 100L;
                }

                // set
                if(nNewBorder != rG.aGradient.GetBorder())
                {
                    rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
                }
            }

            break;
        }
        case XGRAD_AXIAL :
        {
            if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
            {
                basegfx::B2DVector aFullVec(aEndPos - aCenter);
                const basegfx::B2DVector aOldVec(basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()) - aCenter);
                const double fFullLen(aFullVec.getLength());
                const double fOldLen(aOldVec.getLength());
                const double fNewBorder((fFullLen * 100.0) / fOldLen);
                sal_Int32 nNewBorder = 100 - FRound(fNewBorder);

                // clip
                if(nNewBorder < 0L)
                {
                    nNewBorder = 0L;
                }

                if(nNewBorder > 100L)
                {
                    nNewBorder = 100L;
                }

                // set
                if(nNewBorder != rG.aGradient.GetBorder())
                {
                    rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
                }

                aFullVec.normalize();
                double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
                fNewFullAngle /= F_PI180;
                fNewFullAngle *= -10.0;
                fNewFullAngle += 900.0;

                // clip
                while(fNewFullAngle < 0.0)
                {
                    fNewFullAngle += 3600.0;
                }

                while(fNewFullAngle >= 3600.0)
                {
                    fNewFullAngle -= 3600.0;
                }

                // to int and set
                const sal_Int32 nNewAngle(FRound(fNewFullAngle));

                if(nNewAngle != rGOld.aGradient.GetAngle())
                {
                    rG.aGradient.SetAngle(nNewAngle);
                }
            }

            break;
        }
        case XGRAD_RADIAL :
        case XGRAD_SQUARE :
        {
            if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
            {
                const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
                const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
                sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
                sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));

                // clip
                if(nNewXOffset < 0L)
                {
                    nNewXOffset = 0L;
                }

                if(nNewXOffset > 100L)
                {
                    nNewXOffset = 100L;
                }

                if(nNewYOffset < 0L)
                {
                    nNewYOffset = 0L;
                }

                if(nNewYOffset > 100L)
                {
                    nNewYOffset = 100L;
                }

                rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
                rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);

                aStartPos -= aOffset;
                aEndPos -= aOffset;
            }

            if(!bMoveSingle || (bMoveSingle && bMoveFirst))
            {
                basegfx::B2DVector aFullVec(aStartPos - aEndPos);
                const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
                const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
                const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
                const double fFullLen(aFullVec.getLength());
                const double fOldLen(aOldVec.getLength());
                const double fNewBorder((fFullLen * 100.0) / fOldLen);
                sal_Int32 nNewBorder(100L - FRound(fNewBorder));

                // clip
                if(nNewBorder < 0L)
                {
                    nNewBorder = 0L;
                }

                if(nNewBorder > 100L)
                {
                    nNewBorder = 100L;
                }

                // set
                if(nNewBorder != rG.aGradient.GetBorder())
                {
                    rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
                }

                // angle is not definitely necessary for these modes, but it makes
                // controlling more fun for the user
                aFullVec.normalize();
                double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
                fNewFullAngle /= F_PI180;
                fNewFullAngle *= -10.0;
                fNewFullAngle += 900.0;

                // clip
                while(fNewFullAngle < 0.0)
                {
                    fNewFullAngle += 3600.0;
                }

                while(fNewFullAngle >= 3600.0)
                {
                    fNewFullAngle -= 3600.0;
                }

                // to int and set
                const sal_Int32 nNewAngle(FRound(fNewFullAngle));

                if(nNewAngle != rGOld.aGradient.GetAngle())
                {
                    rG.aGradient.SetAngle(nNewAngle);
                }
            }

            break;
        }
        case XGRAD_ELLIPTICAL :
        case XGRAD_RECT :
        {
            if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
            {
                const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
                const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
                sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
                sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));

                // clip
                if(nNewXOffset < 0L)
                {
                    nNewXOffset = 0L;
                }

                if(nNewXOffset > 100L)
                {
                    nNewXOffset = 100L;
                }

                if(nNewYOffset < 0L)
                {
                    nNewYOffset = 0L;
                }

                if(nNewYOffset > 100L)
                {
                    nNewYOffset = 100L;
                }

                rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
                rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);

                aStartPos -= aOffset;
                aEndPos -= aOffset;
            }

            if(!bMoveSingle || (bMoveSingle && bMoveFirst))
            {
                basegfx::B2DVector aFullVec(aStartPos - aEndPos);
                const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
                const basegfx::B2DPoint aCenterLeft(aRange.getMinX(), aRange.getHeight());
                const basegfx::B2DVector aOldVec(aCenterLeft - aTopLeft);
                const double fFullLen(aFullVec.getLength());
                const double fOldLen(aOldVec.getLength());
                const double fNewBorder((fFullLen * 100.0) / fOldLen);
                sal_Int32 nNewBorder(100L - FRound(fNewBorder));

                // clip
                if(nNewBorder < 0L)
                {
                    nNewBorder = 0L;
                }

                if(nNewBorder > 100L)
                {
                    nNewBorder = 100L;
                }

                // set
                if(nNewBorder != rG.aGradient.GetBorder())
                {
                    rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
                }

                // angle is not definitely necessary for these modes, but it makes
                // controlling more fun for the user
                aFullVec.normalize();
                double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
                fNewFullAngle /= F_PI180;
                fNewFullAngle *= -10.0;
                fNewFullAngle += 900.0;

                // clip
                while(fNewFullAngle < 0.0)
                {
                    fNewFullAngle += 3600.0;
                }

                while(fNewFullAngle >= 3600.0)
                {
                    fNewFullAngle -= 3600.0;
                }

                // to int and set
                const sal_Int32 nNewAngle(FRound(fNewFullAngle));

                if(nNewAngle != rGOld.aGradient.GetAngle())
                {
                    rG.aGradient.SetAngle(nNewAngle);
                }
            }

            break;
        }
    }
}

/* vim: set noet sw=4 ts=4: */