/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <lcdgdrv.h>

#include "lcdtransform.h"

#include "calctransform.h"

//

// Compute TLcdTransform mapping aSrcRect to aDstRect with aSrcTransform

//

// returns source to target transform

//

EXPORT_C TLcdTransform CalcTransform

(

    const TRect& aDstRect,          // unclipped

    const TRect& aSrcRect,          // unclipped

    TTransformType aSrcTransform

)

{

    //

    // Transform calculates the TLcdTransform which transforms a rectangle of

    // size aSrcRect.Size(), positioned with its top left corner at the origin,

    // such that the top left corner of the transformed rectangle also lies at

    // the origin.

    //

    TLcdTransform transform = ::Transform(aSrcTransform, aSrcRect.Size());

    //

    // compose transform at origin with src and dst translations.

    //

    transform = Translate(aDstRect.iTl) * transform * Translate(-aSrcRect.iTl);

    //

    // Currently do not support scaling transforms. The following check will

    // catch an attempt to specify a destination rectangle that is not the

    // same size as the transformed source rectangle.

    //

    ASSERT(CheckTransform(aDstRect, aSrcRect, transform));

    return transform;

}

LOCAL_C TRect TransformRect(const TLcdTransform& aTransform, const TRect& aRect)

{

    TRect rect;

    if ((aRect.iBr.iX >= aRect.iTl.iX) && (aRect.iBr.iY >= aRect.iTl.iY))

    {

        //

        // Forward propagate clipped rectangle corners to destination coords.

        // We have to use inclusive-inclusive coords and sort the transformed

        // points to produce a destination rectangle.

        //

        TPoint topLeft     = aRect.iTl;

        TPoint bottomRight = aRect.iBr;

        bottomRight.iX--;   // convert to inclusive coords

        bottomRight.iY--;

        //

        // Transform the points.

        //

        topLeft = aTransform(topLeft);

        bottomRight = aTransform(bottomRight);

        //

        // Now find min and max coords - still inclusive

        //

        TInt xMin = Min(topLeft.iX, bottomRight.iX);

        TInt xMax = Max(topLeft.iX, bottomRight.iX);

        TInt yMin = Min(topLeft.iY, bottomRight.iY);

        TInt yMax = Max(topLeft.iY, bottomRight.iY);

        rect.iTl.iX = xMin;

        rect.iTl.iY = yMin;

        rect.iBr.iX = xMax + 1; // exclusive

        rect.iBr.iY = yMax + 1; // exclusive

    }

    else

    {

        rect.iTl = aTransform(aRect.iTl);

        rect.iBr = rect.iTl;    // exclusive

        ASSERT(rect.IsEmpty());

    }

    return rect;

}

/**

 * Calculate clipped source and destination rectangles for

 * src to dst transform aSrcTransform. This function calculates

 * the largest corresponding subrectangles of aDstRect and aSrcRect

 * that also lie within aDstClipRect and aSrcClipRect respectively.

 */

EXPORT_C void ClipTransformRect

(

    TRect& aDstRect,                    // in/out

    TRect& aSrcRect,                    // in/out

    const TRect& aDstClipRect,          // input

    const TRect& aSrcClipRect,          // input

    TLcdTransform& aSrcTransform        // src to target transform

)

{

    TRect transRect;

    TLcdTransform& forward = aSrcTransform;

    TLcdTransform  reverse = forward.Inverse();

    //

    // Clip source rectangle.

    //

    aSrcRect.Intersection(aSrcClipRect);

    //

    // Clip destination rectangle.

    //

    aDstRect.Intersection(aDstClipRect);

    //

    // Transform clipped source rectangle to destination coords.

    //

    transRect = TransformRect(forward, aSrcRect);

    //

    // Clip againts destination rectangle.

    //

    aDstRect.Intersection(transRect);

    //

    // Reverse transform rectangle clipped against destination clip rect to source coords

    //

    aSrcRect = TransformRect(reverse, aDstRect);

}

//

// Clip source and dst rects against source and dst clip rects, maintaining aspect ratio

//

EXPORT_C void ClipRects(TRect& aDstRect, const TRect& aDstClip, TRect& aSrcRect, const TRect& aSrcClip)

{

    TPoint vector = aDstRect.iTl - aSrcRect.iTl;

    aDstRect.Intersection(aDstClip);

    aSrcRect.Intersection(aSrcClip);

    TRect srcRect(aDstRect.iTl - vector, aDstRect.Size());

    aSrcRect.Intersection(srcRect);

    aDstRect = aSrcRect;

    aDstRect.Move(vector);

    ASSERT(aDstRect.Size() == aSrcRect.Size());

}

#ifdef _DEBUG

void TestDbgCheckTransform()

{

    TLcdTransform transform = Translate(TPoint(-1,1));

    TRect srcRect(TPoint(1,0), TSize(1,2));

    TRect dstRect(TPoint(0,0), TSize(1,2));

    ASSERT(CheckTransform(dstRect, srcRect, transform));

}

#endif

EXPORT_C TBool CheckTransform(const TRect& aDstRect, const TRect& aSrcRect, const TLcdTransform aTransform)

{

    TPoint dst[4];

    TPoint src[4];

    const TPoint* dstPtr[4];

    TInt x1,y1,x2,y2;

    x1=aDstRect.iTl.iX;

    y1=aDstRect.iTl.iY;

    x2=aDstRect.iBr.iX-1;

    y2=aDstRect.iBr.iY-1;

    dst[0].iX = x1;

    dst[0].iY = y1;

    dst[1].iX = x2;

    dst[1].iY = y1;

    dst[2].iX = x1;

    dst[2].iY = y2;

    dst[3].iX = x2;

    dst[3].iY = y2;

    x1=aSrcRect.iTl.iX;

    y1=aSrcRect.iTl.iY;

    x2=aSrcRect.iBr.iX-1;

    y2=aSrcRect.iBr.iY-1;

    src[0].iX = x1;

    src[0].iY = y1;

    src[1].iX = x2;

    src[1].iY = y1;

    src[2].iX = x1;

    src[2].iY = y2;

    src[3].iX = x2;

    src[3].iY = y2;

    dstPtr[0] = &dst[0];

    dstPtr[1] = &dst[1];

    dstPtr[2] = &dst[2];

    dstPtr[3] = &dst[3];

    TPoint p;

    TBool f=ETrue;

    for (TInt i=0; i<4 && f; i++)

    {

        f = EFalse;

        p = aTransform(src[i]);

        for (TInt j=4; --j>=0;)

        {

            if (dstPtr[j] && (*dstPtr[j] == p))

            {

                dstPtr[j] = NULL;

                f = ETrue;

                break;

            }

        }

        ASSERT(f);

    }

    return f;

}

EXPORT_C TBool CheckBounds(const TSize& aDstSize, const TSize& aSrcSize, const TRect& aDstRect, const TLcdTransform& aTransform)

{

    if (!aDstRect.IsEmpty())

    {

        TPoint p1 = aDstRect.iTl;

        TPoint p2 = aDstRect.iBr;

        p2.iX--;

        p2.iY--;

        TRect dstClipRect(aDstSize);

        ASSERT(dstClipRect.Contains(p1));

        if (!dstClipRect.Contains(p1))

        {

            return EFalse;

        }

        ASSERT(dstClipRect.Contains(p2));

        if (!dstClipRect.Contains(p2))

        {

            return EFalse;

        }

        p1 = aTransform(p1);

        p2 = aTransform(p2);

        TRect srcClipRect(aSrcSize);

        ASSERT(srcClipRect.Contains(p1));

        if (!srcClipRect.Contains(p1))

        {

            return EFalse;

        }

        ASSERT(srcClipRect.Contains(p2));

        if (!srcClipRect.Contains(p2))

        {

            return EFalse;

        }

    }

    return ETrue;

}